BBCSD computes the CS decomposition of a unitary matrix in bidiagonal-block form, [ B11 | B12 0 0 ] [ 0 | 0 -I 0 ] X = [----------------] [ B21 | B22 0 0 ] [ 0 | 0 0 I ] [ C | -S 0 0 ] [ U1 | ] [ 0 | 0 -I 0 ] [ V1 | ]**H = [---------] [---------------] [---------] . [ | U2 ] [ S | C 0 0 ] [ | V2 ] [ 0 | 0 0 I ] X is M-by-M, its top-left block is P-by-Q, and Q must be no larger than P, M-P, or M-Q. (If Q is not the smallest index, then X must be transposed and/or permuted. This can be done in constant time using the TRANS and SIGNS options. See CUNCSD for details.) The bidiagonal matrices B11, B12, B21, and B22 are represented implicitly by angles THETA(1:Q) and PHI(1:Q-1). The unitary matrices U1, U2, V1T, and V2T are input/output. The input matrices are pre- or post-multiplied by the appropriate singular vector matrices.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | jobu1 | |||
| character, | intent(in) | :: | jobu2 | |||
| character, | intent(in) | :: | jobv1t | |||
| character, | intent(in) | :: | jobv2t | |||
| character, | intent(in) | :: | trans | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | p | |||
| integer(kind=ilp), | intent(in) | :: | q | |||
| real(kind=sp), | intent(inout) | :: | theta(*) | |||
| real(kind=sp), | intent(inout) | :: | phi(*) | |||
| complex(kind=sp), | intent(inout) | :: | u1(ldu1,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldu1 | |||
| complex(kind=sp), | intent(inout) | :: | u2(ldu2,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldu2 | |||
| complex(kind=sp), | intent(inout) | :: | v1t(ldv1t,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldv1t | |||
| complex(kind=sp), | intent(inout) | :: | v2t(ldv2t,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldv2t | |||
| real(kind=sp), | intent(out) | :: | b11d(*) | |||
| real(kind=sp), | intent(out) | :: | b11e(*) | |||
| real(kind=sp), | intent(out) | :: | b12d(*) | |||
| real(kind=sp), | intent(out) | :: | b12e(*) | |||
| real(kind=sp), | intent(out) | :: | b21d(*) | |||
| real(kind=sp), | intent(out) | :: | b21e(*) | |||
| real(kind=sp), | intent(out) | :: | b22d(*) | |||
| real(kind=sp), | intent(out) | :: | b22e(*) | |||
| real(kind=sp), | intent(out) | :: | rwork(*) | |||
| integer(kind=ilp), | intent(in) | :: | lrwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | jobu1 | |||
| character, | intent(in) | :: | jobu2 | |||
| character, | intent(in) | :: | jobv1t | |||
| character, | intent(in) | :: | jobv2t | |||
| character, | intent(in) | :: | trans | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | p | |||
| integer(kind=ilp), | intent(in) | :: | q | |||
| real(kind=dp), | intent(inout) | :: | theta(*) | |||
| real(kind=dp), | intent(inout) | :: | phi(*) | |||
| real(kind=dp), | intent(inout) | :: | u1(ldu1,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldu1 | |||
| real(kind=dp), | intent(inout) | :: | u2(ldu2,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldu2 | |||
| real(kind=dp), | intent(inout) | :: | v1t(ldv1t,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldv1t | |||
| real(kind=dp), | intent(inout) | :: | v2t(ldv2t,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldv2t | |||
| real(kind=dp), | intent(out) | :: | b11d(*) | |||
| real(kind=dp), | intent(out) | :: | b11e(*) | |||
| real(kind=dp), | intent(out) | :: | b12d(*) | |||
| real(kind=dp), | intent(out) | :: | b12e(*) | |||
| real(kind=dp), | intent(out) | :: | b21d(*) | |||
| real(kind=dp), | intent(out) | :: | b21e(*) | |||
| real(kind=dp), | intent(out) | :: | b22d(*) | |||
| real(kind=dp), | intent(out) | :: | b22e(*) | |||
| real(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | jobu1 | |||
| character, | intent(in) | :: | jobu2 | |||
| character, | intent(in) | :: | jobv1t | |||
| character, | intent(in) | :: | jobv2t | |||
| character, | intent(in) | :: | trans | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | p | |||
| integer(kind=ilp), | intent(in) | :: | q | |||
| real(kind=sp), | intent(inout) | :: | theta(*) | |||
| real(kind=sp), | intent(inout) | :: | phi(*) | |||
| real(kind=sp), | intent(inout) | :: | u1(ldu1,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldu1 | |||
| real(kind=sp), | intent(inout) | :: | u2(ldu2,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldu2 | |||
| real(kind=sp), | intent(inout) | :: | v1t(ldv1t,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldv1t | |||
| real(kind=sp), | intent(inout) | :: | v2t(ldv2t,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldv2t | |||
| real(kind=sp), | intent(out) | :: | b11d(*) | |||
| real(kind=sp), | intent(out) | :: | b11e(*) | |||
| real(kind=sp), | intent(out) | :: | b12d(*) | |||
| real(kind=sp), | intent(out) | :: | b12e(*) | |||
| real(kind=sp), | intent(out) | :: | b21d(*) | |||
| real(kind=sp), | intent(out) | :: | b21e(*) | |||
| real(kind=sp), | intent(out) | :: | b22d(*) | |||
| real(kind=sp), | intent(out) | :: | b22e(*) | |||
| real(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | jobu1 | |||
| character, | intent(in) | :: | jobu2 | |||
| character, | intent(in) | :: | jobv1t | |||
| character, | intent(in) | :: | jobv2t | |||
| character, | intent(in) | :: | trans | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | p | |||
| integer(kind=ilp), | intent(in) | :: | q | |||
| real(kind=dp), | intent(inout) | :: | theta(*) | |||
| real(kind=dp), | intent(inout) | :: | phi(*) | |||
| complex(kind=dp), | intent(inout) | :: | u1(ldu1,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldu1 | |||
| complex(kind=dp), | intent(inout) | :: | u2(ldu2,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldu2 | |||
| complex(kind=dp), | intent(inout) | :: | v1t(ldv1t,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldv1t | |||
| complex(kind=dp), | intent(inout) | :: | v2t(ldv2t,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldv2t | |||
| real(kind=dp), | intent(out) | :: | b11d(*) | |||
| real(kind=dp), | intent(out) | :: | b11e(*) | |||
| real(kind=dp), | intent(out) | :: | b12d(*) | |||
| real(kind=dp), | intent(out) | :: | b12e(*) | |||
| real(kind=dp), | intent(out) | :: | b21d(*) | |||
| real(kind=dp), | intent(out) | :: | b21e(*) | |||
| real(kind=dp), | intent(out) | :: | b22d(*) | |||
| real(kind=dp), | intent(out) | :: | b22e(*) | |||
| real(kind=dp), | intent(out) | :: | rwork(*) | |||
| integer(kind=ilp), | intent(in) | :: | lrwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
CBBCSD computes the CS decomposition of a unitary matrix in bidiagonal-block form, [ B11 | B12 0 0 ] [ 0 | 0 -I 0 ] X = [----------------] [ B21 | B22 0 0 ] [ 0 | 0 0 I ] [ C | -S 0 0 ] [ U1 | ] [ 0 | 0 -I 0 ] [ V1 | ]**H = [---------] [---------------] [---------] . [ | U2 ] [ S | C 0 0 ] [ | V2 ] [ 0 | 0 0 I ] X is M-by-M, its top-left block is P-by-Q, and Q must be no larger than P, M-P, or M-Q. (If Q is not the smallest index, then X must be transposed and/or permuted. This can be done in constant time using the TRANS and SIGNS options. See CUNCSD for details.) The bidiagonal matrices B11, B12, B21, and B22 are represented implicitly by angles THETA(1:Q) and PHI(1:Q-1). The unitary matrices U1, U2, V1T, and V2T are input/output. The input matrices are pre- or post-multiplied by the appropriate singular vector matrices.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | jobu1 | |||
| character, | intent(in) | :: | jobu2 | |||
| character, | intent(in) | :: | jobv1t | |||
| character, | intent(in) | :: | jobv2t | |||
| character, | intent(in) | :: | trans | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | p | |||
| integer(kind=ilp), | intent(in) | :: | q | |||
| real(kind=sp), | intent(inout) | :: | theta(*) | |||
| real(kind=sp), | intent(inout) | :: | phi(*) | |||
| complex(kind=sp), | intent(inout) | :: | u1(ldu1,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldu1 | |||
| complex(kind=sp), | intent(inout) | :: | u2(ldu2,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldu2 | |||
| complex(kind=sp), | intent(inout) | :: | v1t(ldv1t,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldv1t | |||
| complex(kind=sp), | intent(inout) | :: | v2t(ldv2t,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldv2t | |||
| real(kind=sp), | intent(out) | :: | b11d(*) | |||
| real(kind=sp), | intent(out) | :: | b11e(*) | |||
| real(kind=sp), | intent(out) | :: | b12d(*) | |||
| real(kind=sp), | intent(out) | :: | b12e(*) | |||
| real(kind=sp), | intent(out) | :: | b21d(*) | |||
| real(kind=sp), | intent(out) | :: | b21e(*) | |||
| real(kind=sp), | intent(out) | :: | b22d(*) | |||
| real(kind=sp), | intent(out) | :: | b22e(*) | |||
| real(kind=sp), | intent(out) | :: | rwork(*) | |||
| integer(kind=ilp), | intent(in) | :: | lrwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
DBBCSD computes the CS decomposition of an orthogonal matrix in bidiagonal-block form, [ B11 | B12 0 0 ] [ 0 | 0 -I 0 ] X = [----------------] [ B21 | B22 0 0 ] [ 0 | 0 0 I ] [ C | -S 0 0 ] [ U1 | ] [ 0 | 0 -I 0 ] [ V1 | ]**T = [---------] [---------------] [---------] . [ | U2 ] [ S | C 0 0 ] [ | V2 ] [ 0 | 0 0 I ] X is M-by-M, its top-left block is P-by-Q, and Q must be no larger than P, M-P, or M-Q. (If Q is not the smallest index, then X must be transposed and/or permuted. This can be done in constant time using the TRANS and SIGNS options. See DORCSD for details.) The bidiagonal matrices B11, B12, B21, and B22 are represented implicitly by angles THETA(1:Q) and PHI(1:Q-1). The orthogonal matrices U1, U2, V1T, and V2T are input/output. The input matrices are pre- or post-multiplied by the appropriate singular vector matrices.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | jobu1 | |||
| character, | intent(in) | :: | jobu2 | |||
| character, | intent(in) | :: | jobv1t | |||
| character, | intent(in) | :: | jobv2t | |||
| character, | intent(in) | :: | trans | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | p | |||
| integer(kind=ilp), | intent(in) | :: | q | |||
| real(kind=dp), | intent(inout) | :: | theta(*) | |||
| real(kind=dp), | intent(inout) | :: | phi(*) | |||
| real(kind=dp), | intent(inout) | :: | u1(ldu1,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldu1 | |||
| real(kind=dp), | intent(inout) | :: | u2(ldu2,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldu2 | |||
| real(kind=dp), | intent(inout) | :: | v1t(ldv1t,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldv1t | |||
| real(kind=dp), | intent(inout) | :: | v2t(ldv2t,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldv2t | |||
| real(kind=dp), | intent(out) | :: | b11d(*) | |||
| real(kind=dp), | intent(out) | :: | b11e(*) | |||
| real(kind=dp), | intent(out) | :: | b12d(*) | |||
| real(kind=dp), | intent(out) | :: | b12e(*) | |||
| real(kind=dp), | intent(out) | :: | b21d(*) | |||
| real(kind=dp), | intent(out) | :: | b21e(*) | |||
| real(kind=dp), | intent(out) | :: | b22d(*) | |||
| real(kind=dp), | intent(out) | :: | b22e(*) | |||
| real(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
SBBCSD computes the CS decomposition of an orthogonal matrix in bidiagonal-block form, [ B11 | B12 0 0 ] [ 0 | 0 -I 0 ] X = [----------------] [ B21 | B22 0 0 ] [ 0 | 0 0 I ] [ C | -S 0 0 ] [ U1 | ] [ 0 | 0 -I 0 ] [ V1 | ]**T = [---------] [---------------] [---------] . [ | U2 ] [ S | C 0 0 ] [ | V2 ] [ 0 | 0 0 I ] X is M-by-M, its top-left block is P-by-Q, and Q must be no larger than P, M-P, or M-Q. (If Q is not the smallest index, then X must be transposed and/or permuted. This can be done in constant time using the TRANS and SIGNS options. See SORCSD for details.) The bidiagonal matrices B11, B12, B21, and B22 are represented implicitly by angles THETA(1:Q) and PHI(1:Q-1). The orthogonal matrices U1, U2, V1T, and V2T are input/output. The input matrices are pre- or post-multiplied by the appropriate singular vector matrices.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | jobu1 | |||
| character, | intent(in) | :: | jobu2 | |||
| character, | intent(in) | :: | jobv1t | |||
| character, | intent(in) | :: | jobv2t | |||
| character, | intent(in) | :: | trans | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | p | |||
| integer(kind=ilp), | intent(in) | :: | q | |||
| real(kind=sp), | intent(inout) | :: | theta(*) | |||
| real(kind=sp), | intent(inout) | :: | phi(*) | |||
| real(kind=sp), | intent(inout) | :: | u1(ldu1,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldu1 | |||
| real(kind=sp), | intent(inout) | :: | u2(ldu2,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldu2 | |||
| real(kind=sp), | intent(inout) | :: | v1t(ldv1t,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldv1t | |||
| real(kind=sp), | intent(inout) | :: | v2t(ldv2t,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldv2t | |||
| real(kind=sp), | intent(out) | :: | b11d(*) | |||
| real(kind=sp), | intent(out) | :: | b11e(*) | |||
| real(kind=sp), | intent(out) | :: | b12d(*) | |||
| real(kind=sp), | intent(out) | :: | b12e(*) | |||
| real(kind=sp), | intent(out) | :: | b21d(*) | |||
| real(kind=sp), | intent(out) | :: | b21e(*) | |||
| real(kind=sp), | intent(out) | :: | b22d(*) | |||
| real(kind=sp), | intent(out) | :: | b22e(*) | |||
| real(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
ZBBCSD computes the CS decomposition of a unitary matrix in bidiagonal-block form, [ B11 | B12 0 0 ] [ 0 | 0 -I 0 ] X = [----------------] [ B21 | B22 0 0 ] [ 0 | 0 0 I ] [ C | -S 0 0 ] [ U1 | ] [ 0 | 0 -I 0 ] [ V1 | ]**H = [---------] [---------------] [---------] . [ | U2 ] [ S | C 0 0 ] [ | V2 ] [ 0 | 0 0 I ] X is M-by-M, its top-left block is P-by-Q, and Q must be no larger than P, M-P, or M-Q. (If Q is not the smallest index, then X must be transposed and/or permuted. This can be done in constant time using the TRANS and SIGNS options. See ZUNCSD for details.) The bidiagonal matrices B11, B12, B21, and B22 are represented implicitly by angles THETA(1:Q) and PHI(1:Q-1). The unitary matrices U1, U2, V1T, and V2T are input/output. The input matrices are pre- or post-multiplied by the appropriate singular vector matrices.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | jobu1 | |||
| character, | intent(in) | :: | jobu2 | |||
| character, | intent(in) | :: | jobv1t | |||
| character, | intent(in) | :: | jobv2t | |||
| character, | intent(in) | :: | trans | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | p | |||
| integer(kind=ilp), | intent(in) | :: | q | |||
| real(kind=dp), | intent(inout) | :: | theta(*) | |||
| real(kind=dp), | intent(inout) | :: | phi(*) | |||
| complex(kind=dp), | intent(inout) | :: | u1(ldu1,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldu1 | |||
| complex(kind=dp), | intent(inout) | :: | u2(ldu2,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldu2 | |||
| complex(kind=dp), | intent(inout) | :: | v1t(ldv1t,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldv1t | |||
| complex(kind=dp), | intent(inout) | :: | v2t(ldv2t,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldv2t | |||
| real(kind=dp), | intent(out) | :: | b11d(*) | |||
| real(kind=dp), | intent(out) | :: | b11e(*) | |||
| real(kind=dp), | intent(out) | :: | b12d(*) | |||
| real(kind=dp), | intent(out) | :: | b12e(*) | |||
| real(kind=dp), | intent(out) | :: | b21d(*) | |||
| real(kind=dp), | intent(out) | :: | b21e(*) | |||
| real(kind=dp), | intent(out) | :: | b22d(*) | |||
| real(kind=dp), | intent(out) | :: | b22e(*) | |||
| real(kind=dp), | intent(out) | :: | rwork(*) | |||
| integer(kind=ilp), | intent(in) | :: | lrwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
BDSDC computes the singular value decomposition (SVD) of a real N-by-N (upper or lower) bidiagonal matrix B: B = U * S * VT, using a divide and conquer method, where S is a diagonal matrix with non-negative diagonal elements (the singular values of B), and U and VT are orthogonal matrices of left and right singular vectors, respectively. BDSDC can be used to compute all singular values, and optionally, singular vectors or singular vectors in compact form. This code makes very mild assumptions about floating point arithmetic. It will work on machines with a guard digit in add/subtract, or on those binary machines without guard digits which subtract like the Cray X-MP, Cray Y-MP, Cray C-90, or Cray-2. It could conceivably fail on hexadecimal or decimal machines without guard digits, but we know of none. See DLASD3 for details. The code currently calls DLASDQ if singular values only are desired. However, it can be slightly modified to compute singular values using the divide and conquer method.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| character, | intent(in) | :: | compq | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=dp), | intent(inout) | :: | d(*) | |||
| real(kind=dp), | intent(inout) | :: | e(*) | |||
| real(kind=dp), | intent(out) | :: | u(ldu,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldu | |||
| real(kind=dp), | intent(out) | :: | vt(ldvt,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldvt | |||
| real(kind=dp), | intent(out) | :: | q(*) | |||
| integer(kind=ilp), | intent(out) | :: | iq(*) | |||
| real(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | iwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| character, | intent(in) | :: | compq | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=sp), | intent(inout) | :: | d(*) | |||
| real(kind=sp), | intent(inout) | :: | e(*) | |||
| real(kind=sp), | intent(out) | :: | u(ldu,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldu | |||
| real(kind=sp), | intent(out) | :: | vt(ldvt,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldvt | |||
| real(kind=sp), | intent(out) | :: | q(*) | |||
| integer(kind=ilp), | intent(out) | :: | iq(*) | |||
| real(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | iwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
DBDSDC computes the singular value decomposition (SVD) of a real N-by-N (upper or lower) bidiagonal matrix B: B = U * S * VT, using a divide and conquer method, where S is a diagonal matrix with non-negative diagonal elements (the singular values of B), and U and VT are orthogonal matrices of left and right singular vectors, respectively. DBDSDC can be used to compute all singular values, and optionally, singular vectors or singular vectors in compact form. This code makes very mild assumptions about floating point arithmetic. It will work on machines with a guard digit in add/subtract, or on those binary machines without guard digits which subtract like the Cray X-MP, Cray Y-MP, Cray C-90, or Cray-2. It could conceivably fail on hexadecimal or decimal machines without guard digits, but we know of none. See DLASD3 for details. The code currently calls DLASDQ if singular values only are desired. However, it can be slightly modified to compute singular values using the divide and conquer method.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| character, | intent(in) | :: | compq | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=dp), | intent(inout) | :: | d(*) | |||
| real(kind=dp), | intent(inout) | :: | e(*) | |||
| real(kind=dp), | intent(out) | :: | u(ldu,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldu | |||
| real(kind=dp), | intent(out) | :: | vt(ldvt,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldvt | |||
| real(kind=dp), | intent(out) | :: | q(*) | |||
| integer(kind=ilp), | intent(out) | :: | iq(*) | |||
| real(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | iwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
SBDSDC computes the singular value decomposition (SVD) of a real N-by-N (upper or lower) bidiagonal matrix B: B = U * S * VT, using a divide and conquer method, where S is a diagonal matrix with non-negative diagonal elements (the singular values of B), and U and VT are orthogonal matrices of left and right singular vectors, respectively. SBDSDC can be used to compute all singular values, and optionally, singular vectors or singular vectors in compact form. This code makes very mild assumptions about floating point arithmetic. It will work on machines with a guard digit in add/subtract, or on those binary machines without guard digits which subtract like the Cray X-MP, Cray Y-MP, Cray C-90, or Cray-2. It could conceivably fail on hexadecimal or decimal machines without guard digits, but we know of none. See SLASD3 for details. The code currently calls SLASDQ if singular values only are desired. However, it can be slightly modified to compute singular values using the divide and conquer method.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| character, | intent(in) | :: | compq | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=sp), | intent(inout) | :: | d(*) | |||
| real(kind=sp), | intent(inout) | :: | e(*) | |||
| real(kind=sp), | intent(out) | :: | u(ldu,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldu | |||
| real(kind=sp), | intent(out) | :: | vt(ldvt,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldvt | |||
| real(kind=sp), | intent(out) | :: | q(*) | |||
| integer(kind=ilp), | intent(out) | :: | iq(*) | |||
| real(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | iwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
BDSQR computes the singular values and, optionally, the right and/or left singular vectors from the singular value decomposition (SVD) of a real N-by-N (upper or lower) bidiagonal matrix B using the implicit zero-shift QR algorithm. The SVD of B has the form B = Q * S * PH where S is the diagonal matrix of singular values, Q is an orthogonal matrix of left singular vectors, and P is an orthogonal matrix of right singular vectors. If left singular vectors are requested, this subroutine actually returns U*Q instead of Q, and, if right singular vectors are requested, this subroutine returns PHVT instead of PH, for given complex input matrices U and VT. When U and VT are the unitary matrices that reduce a general matrix A to bidiagonal form: A = UBVT, as computed by CGEBRD, then A = (UQ) * S * (PH*VT) is the SVD of A. Optionally, the subroutine may also compute QH*C for a given complex input matrix C. See "Computing Small Singular Values of Bidiagonal Matrices With Guaranteed High Relative Accuracy," by J. Demmel and W. Kahan, LAPACK Working Note #3 (or SIAM J. Sci. Statist. Comput. vol. 11, no. 5, pp. 873-912, Sept 1990) and "Accurate singular values and differential qd algorithms," by B. Parlett and V. Fernando, Technical Report CPAM-554, Mathematics Department, University of California at Berkeley, July 1992 for a detailed description of the algorithm.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | ncvt | |||
| integer(kind=ilp), | intent(in) | :: | nru | |||
| integer(kind=ilp), | intent(in) | :: | ncc | |||
| real(kind=sp), | intent(inout) | :: | d(*) | |||
| real(kind=sp), | intent(inout) | :: | e(*) | |||
| complex(kind=sp), | intent(inout) | :: | vt(ldvt,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldvt | |||
| complex(kind=sp), | intent(inout) | :: | u(ldu,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldu | |||
| complex(kind=sp), | intent(inout) | :: | c(ldc,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldc | |||
| real(kind=sp), | intent(out) | :: | rwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | ncvt | |||
| integer(kind=ilp), | intent(in) | :: | nru | |||
| integer(kind=ilp), | intent(in) | :: | ncc | |||
| real(kind=dp), | intent(inout) | :: | d(*) | |||
| real(kind=dp), | intent(inout) | :: | e(*) | |||
| real(kind=dp), | intent(inout) | :: | vt(ldvt,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldvt | |||
| real(kind=dp), | intent(inout) | :: | u(ldu,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldu | |||
| real(kind=dp), | intent(inout) | :: | c(ldc,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldc | |||
| real(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | ncvt | |||
| integer(kind=ilp), | intent(in) | :: | nru | |||
| integer(kind=ilp), | intent(in) | :: | ncc | |||
| real(kind=sp), | intent(inout) | :: | d(*) | |||
| real(kind=sp), | intent(inout) | :: | e(*) | |||
| real(kind=sp), | intent(inout) | :: | vt(ldvt,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldvt | |||
| real(kind=sp), | intent(inout) | :: | u(ldu,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldu | |||
| real(kind=sp), | intent(inout) | :: | c(ldc,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldc | |||
| real(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | ncvt | |||
| integer(kind=ilp), | intent(in) | :: | nru | |||
| integer(kind=ilp), | intent(in) | :: | ncc | |||
| real(kind=dp), | intent(inout) | :: | d(*) | |||
| real(kind=dp), | intent(inout) | :: | e(*) | |||
| complex(kind=dp), | intent(inout) | :: | vt(ldvt,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldvt | |||
| complex(kind=dp), | intent(inout) | :: | u(ldu,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldu | |||
| complex(kind=dp), | intent(inout) | :: | c(ldc,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldc | |||
| real(kind=dp), | intent(out) | :: | rwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
CBDSQR computes the singular values and, optionally, the right and/or left singular vectors from the singular value decomposition (SVD) of a real N-by-N (upper or lower) bidiagonal matrix B using the implicit zero-shift QR algorithm. The SVD of B has the form B = Q * S * PH where S is the diagonal matrix of singular values, Q is an orthogonal matrix of left singular vectors, and P is an orthogonal matrix of right singular vectors. If left singular vectors are requested, this subroutine actually returns U*Q instead of Q, and, if right singular vectors are requested, this subroutine returns PHVT instead of PH, for given complex input matrices U and VT. When U and VT are the unitary matrices that reduce a general matrix A to bidiagonal form: A = UBVT, as computed by CGEBRD, then A = (UQ) * S * (PH*VT) is the SVD of A. Optionally, the subroutine may also compute QH*C for a given complex input matrix C. See "Computing Small Singular Values of Bidiagonal Matrices With Guaranteed High Relative Accuracy," by J. Demmel and W. Kahan, LAPACK Working Note #3 (or SIAM J. Sci. Statist. Comput. vol. 11, no. 5, pp. 873-912, Sept 1990) and "Accurate singular values and differential qd algorithms," by B. Parlett and V. Fernando, Technical Report CPAM-554, Mathematics Department, University of California at Berkeley, July 1992 for a detailed description of the algorithm.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | ncvt | |||
| integer(kind=ilp), | intent(in) | :: | nru | |||
| integer(kind=ilp), | intent(in) | :: | ncc | |||
| real(kind=sp), | intent(inout) | :: | d(*) | |||
| real(kind=sp), | intent(inout) | :: | e(*) | |||
| complex(kind=sp), | intent(inout) | :: | vt(ldvt,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldvt | |||
| complex(kind=sp), | intent(inout) | :: | u(ldu,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldu | |||
| complex(kind=sp), | intent(inout) | :: | c(ldc,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldc | |||
| real(kind=sp), | intent(out) | :: | rwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
DBDSQR computes the singular values and, optionally, the right and/or left singular vectors from the singular value decomposition (SVD) of a real N-by-N (upper or lower) bidiagonal matrix B using the implicit zero-shift QR algorithm. The SVD of B has the form B = Q * S * PT where S is the diagonal matrix of singular values, Q is an orthogonal matrix of left singular vectors, and P is an orthogonal matrix of right singular vectors. If left singular vectors are requested, this subroutine actually returns U*Q instead of Q, and, if right singular vectors are requested, this subroutine returns PTVT instead of PT, for given real input matrices U and VT. When U and VT are the orthogonal matrices that reduce a general matrix A to bidiagonal form: A = UBVT, as computed by DGEBRD, then A = (UQ) * S * (PT*VT) is the SVD of A. Optionally, the subroutine may also compute QT*C for a given real input matrix C. See "Computing Small Singular Values of Bidiagonal Matrices With Guaranteed High Relative Accuracy," by J. Demmel and W. Kahan, LAPACK Working Note #3 (or SIAM J. Sci. Statist. Comput. vol. 11, no. 5, pp. 873-912, Sept 1990) and "Accurate singular values and differential qd algorithms," by B. Parlett and V. Fernando, Technical Report CPAM-554, Mathematics Department, University of California at Berkeley, July 1992 for a detailed description of the algorithm.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | ncvt | |||
| integer(kind=ilp), | intent(in) | :: | nru | |||
| integer(kind=ilp), | intent(in) | :: | ncc | |||
| real(kind=dp), | intent(inout) | :: | d(*) | |||
| real(kind=dp), | intent(inout) | :: | e(*) | |||
| real(kind=dp), | intent(inout) | :: | vt(ldvt,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldvt | |||
| real(kind=dp), | intent(inout) | :: | u(ldu,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldu | |||
| real(kind=dp), | intent(inout) | :: | c(ldc,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldc | |||
| real(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
SBDSQR computes the singular values and, optionally, the right and/or left singular vectors from the singular value decomposition (SVD) of a real N-by-N (upper or lower) bidiagonal matrix B using the implicit zero-shift QR algorithm. The SVD of B has the form B = Q * S * PT where S is the diagonal matrix of singular values, Q is an orthogonal matrix of left singular vectors, and P is an orthogonal matrix of right singular vectors. If left singular vectors are requested, this subroutine actually returns U*Q instead of Q, and, if right singular vectors are requested, this subroutine returns PTVT instead of PT, for given real input matrices U and VT. When U and VT are the orthogonal matrices that reduce a general matrix A to bidiagonal form: A = UBVT, as computed by SGEBRD, then A = (UQ) * S * (PT*VT) is the SVD of A. Optionally, the subroutine may also compute QT*C for a given real input matrix C. See "Computing Small Singular Values of Bidiagonal Matrices With Guaranteed High Relative Accuracy," by J. Demmel and W. Kahan, LAPACK Working Note #3 (or SIAM J. Sci. Statist. Comput. vol. 11, no. 5, pp. 873-912, Sept 1990) and "Accurate singular values and differential qd algorithms," by B. Parlett and V. Fernando, Technical Report CPAM-554, Mathematics Department, University of California at Berkeley, July 1992 for a detailed description of the algorithm.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | ncvt | |||
| integer(kind=ilp), | intent(in) | :: | nru | |||
| integer(kind=ilp), | intent(in) | :: | ncc | |||
| real(kind=sp), | intent(inout) | :: | d(*) | |||
| real(kind=sp), | intent(inout) | :: | e(*) | |||
| real(kind=sp), | intent(inout) | :: | vt(ldvt,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldvt | |||
| real(kind=sp), | intent(inout) | :: | u(ldu,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldu | |||
| real(kind=sp), | intent(inout) | :: | c(ldc,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldc | |||
| real(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
ZBDSQR computes the singular values and, optionally, the right and/or left singular vectors from the singular value decomposition (SVD) of a real N-by-N (upper or lower) bidiagonal matrix B using the implicit zero-shift QR algorithm. The SVD of B has the form B = Q * S * PH where S is the diagonal matrix of singular values, Q is an orthogonal matrix of left singular vectors, and P is an orthogonal matrix of right singular vectors. If left singular vectors are requested, this subroutine actually returns U*Q instead of Q, and, if right singular vectors are requested, this subroutine returns PHVT instead of PH, for given complex input matrices U and VT. When U and VT are the unitary matrices that reduce a general matrix A to bidiagonal form: A = UBVT, as computed by ZGEBRD, then A = (UQ) * S * (PH*VT) is the SVD of A. Optionally, the subroutine may also compute QH*C for a given complex input matrix C. See "Computing Small Singular Values of Bidiagonal Matrices With Guaranteed High Relative Accuracy," by J. Demmel and W. Kahan, LAPACK Working Note #3 (or SIAM J. Sci. Statist. Comput. vol. 11, no. 5, pp. 873-912, Sept 1990) and "Accurate singular values and differential qd algorithms," by B. Parlett and V. Fernando, Technical Report CPAM-554, Mathematics Department, University of California at Berkeley, July 1992 for a detailed description of the algorithm.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | ncvt | |||
| integer(kind=ilp), | intent(in) | :: | nru | |||
| integer(kind=ilp), | intent(in) | :: | ncc | |||
| real(kind=dp), | intent(inout) | :: | d(*) | |||
| real(kind=dp), | intent(inout) | :: | e(*) | |||
| complex(kind=dp), | intent(inout) | :: | vt(ldvt,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldvt | |||
| complex(kind=dp), | intent(inout) | :: | u(ldu,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldu | |||
| complex(kind=dp), | intent(inout) | :: | c(ldc,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldc | |||
| real(kind=dp), | intent(out) | :: | rwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
DISNA computes the reciprocal condition numbers for the eigenvectors of a real symmetric or complex Hermitian matrix or for the left or right singular vectors of a general m-by-n matrix. The reciprocal condition number is the 'gap' between the corresponding eigenvalue or singular value and the nearest other one. The bound on the error, measured by angle in radians, in the I-th computed vector is given by DLAMCH( 'E' ) * ( ANORM / SEP( I ) ) where ANORM = 2-norm(A) = max( abs( D(j) ) ). SEP(I) is not allowed to be smaller than DLAMCH( 'E' )*ANORM in order to limit the size of the error bound. DISNA may also be used to compute error bounds for eigenvectors of the generalized symmetric definite eigenproblem.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | job | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=dp), | intent(in) | :: | d(*) | |||
| real(kind=dp), | intent(out) | :: | sep(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | job | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=sp), | intent(in) | :: | d(*) | |||
| real(kind=sp), | intent(out) | :: | sep(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
DDISNA computes the reciprocal condition numbers for the eigenvectors of a real symmetric or complex Hermitian matrix or for the left or right singular vectors of a general m-by-n matrix. The reciprocal condition number is the 'gap' between the corresponding eigenvalue or singular value and the nearest other one. The bound on the error, measured by angle in radians, in the I-th computed vector is given by DLAMCH( 'E' ) * ( ANORM / SEP( I ) ) where ANORM = 2-norm(A) = max( abs( D(j) ) ). SEP(I) is not allowed to be smaller than DLAMCH( 'E' )*ANORM in order to limit the size of the error bound. DDISNA may also be used to compute error bounds for eigenvectors of the generalized symmetric definite eigenproblem.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | job | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=dp), | intent(in) | :: | d(*) | |||
| real(kind=dp), | intent(out) | :: | sep(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
SDISNA computes the reciprocal condition numbers for the eigenvectors of a real symmetric or complex Hermitian matrix or for the left or right singular vectors of a general m-by-n matrix. The reciprocal condition number is the 'gap' between the corresponding eigenvalue or singular value and the nearest other one. The bound on the error, measured by angle in radians, in the I-th computed vector is given by SLAMCH( 'E' ) * ( ANORM / SEP( I ) ) where ANORM = 2-norm(A) = max( abs( D(j) ) ). SEP(I) is not allowed to be smaller than SLAMCH( 'E' )*ANORM in order to limit the size of the error bound. SDISNA may also be used to compute error bounds for eigenvectors of the generalized symmetric definite eigenproblem.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | job | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=sp), | intent(in) | :: | d(*) | |||
| real(kind=sp), | intent(out) | :: | sep(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
GBBRD reduces a complex general m-by-n band matrix A to real upper bidiagonal form B by a unitary transformation: QH * A * P = B. The routine computes B, and optionally forms Q or PH, or computes Q*HC for a given matrix C.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | vect | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | ncc | |||
| integer(kind=ilp), | intent(in) | :: | kl | |||
| integer(kind=ilp), | intent(in) | :: | ku | |||
| complex(kind=sp), | intent(inout) | :: | ab(ldab,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldab | |||
| real(kind=sp), | intent(out) | :: | d(*) | |||
| real(kind=sp), | intent(out) | :: | e(*) | |||
| complex(kind=sp), | intent(out) | :: | q(ldq,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldq | |||
| complex(kind=sp), | intent(out) | :: | pt(ldpt,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldpt | |||
| complex(kind=sp), | intent(inout) | :: | c(ldc,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldc | |||
| complex(kind=sp), | intent(out) | :: | work(*) | |||
| real(kind=sp), | intent(out) | :: | rwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | vect | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | ncc | |||
| integer(kind=ilp), | intent(in) | :: | kl | |||
| integer(kind=ilp), | intent(in) | :: | ku | |||
| real(kind=dp), | intent(inout) | :: | ab(ldab,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldab | |||
| real(kind=dp), | intent(out) | :: | d(*) | |||
| real(kind=dp), | intent(out) | :: | e(*) | |||
| real(kind=dp), | intent(out) | :: | q(ldq,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldq | |||
| real(kind=dp), | intent(out) | :: | pt(ldpt,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldpt | |||
| real(kind=dp), | intent(inout) | :: | c(ldc,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldc | |||
| real(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | vect | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | ncc | |||
| integer(kind=ilp), | intent(in) | :: | kl | |||
| integer(kind=ilp), | intent(in) | :: | ku | |||
| real(kind=sp), | intent(inout) | :: | ab(ldab,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldab | |||
| real(kind=sp), | intent(out) | :: | d(*) | |||
| real(kind=sp), | intent(out) | :: | e(*) | |||
| real(kind=sp), | intent(out) | :: | q(ldq,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldq | |||
| real(kind=sp), | intent(out) | :: | pt(ldpt,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldpt | |||
| real(kind=sp), | intent(inout) | :: | c(ldc,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldc | |||
| real(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | vect | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | ncc | |||
| integer(kind=ilp), | intent(in) | :: | kl | |||
| integer(kind=ilp), | intent(in) | :: | ku | |||
| complex(kind=dp), | intent(inout) | :: | ab(ldab,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldab | |||
| real(kind=dp), | intent(out) | :: | d(*) | |||
| real(kind=dp), | intent(out) | :: | e(*) | |||
| complex(kind=dp), | intent(out) | :: | q(ldq,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldq | |||
| complex(kind=dp), | intent(out) | :: | pt(ldpt,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldpt | |||
| complex(kind=dp), | intent(inout) | :: | c(ldc,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldc | |||
| complex(kind=dp), | intent(out) | :: | work(*) | |||
| real(kind=dp), | intent(out) | :: | rwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
CGBBRD reduces a complex general m-by-n band matrix A to real upper bidiagonal form B by a unitary transformation: QH * A * P = B. The routine computes B, and optionally forms Q or PH, or computes Q*HC for a given matrix C.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | vect | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | ncc | |||
| integer(kind=ilp), | intent(in) | :: | kl | |||
| integer(kind=ilp), | intent(in) | :: | ku | |||
| complex(kind=sp), | intent(inout) | :: | ab(ldab,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldab | |||
| real(kind=sp), | intent(out) | :: | d(*) | |||
| real(kind=sp), | intent(out) | :: | e(*) | |||
| complex(kind=sp), | intent(out) | :: | q(ldq,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldq | |||
| complex(kind=sp), | intent(out) | :: | pt(ldpt,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldpt | |||
| complex(kind=sp), | intent(inout) | :: | c(ldc,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldc | |||
| complex(kind=sp), | intent(out) | :: | work(*) | |||
| real(kind=sp), | intent(out) | :: | rwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
DGBBRD reduces a real general m-by-n band matrix A to upper bidiagonal form B by an orthogonal transformation: QT * A * P = B. The routine computes B, and optionally forms Q or PT, or computes Q*TC for a given matrix C.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | vect | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | ncc | |||
| integer(kind=ilp), | intent(in) | :: | kl | |||
| integer(kind=ilp), | intent(in) | :: | ku | |||
| real(kind=dp), | intent(inout) | :: | ab(ldab,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldab | |||
| real(kind=dp), | intent(out) | :: | d(*) | |||
| real(kind=dp), | intent(out) | :: | e(*) | |||
| real(kind=dp), | intent(out) | :: | q(ldq,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldq | |||
| real(kind=dp), | intent(out) | :: | pt(ldpt,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldpt | |||
| real(kind=dp), | intent(inout) | :: | c(ldc,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldc | |||
| real(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
SGBBRD reduces a real general m-by-n band matrix A to upper bidiagonal form B by an orthogonal transformation: QT * A * P = B. The routine computes B, and optionally forms Q or PT, or computes Q*TC for a given matrix C.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | vect | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | ncc | |||
| integer(kind=ilp), | intent(in) | :: | kl | |||
| integer(kind=ilp), | intent(in) | :: | ku | |||
| real(kind=sp), | intent(inout) | :: | ab(ldab,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldab | |||
| real(kind=sp), | intent(out) | :: | d(*) | |||
| real(kind=sp), | intent(out) | :: | e(*) | |||
| real(kind=sp), | intent(out) | :: | q(ldq,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldq | |||
| real(kind=sp), | intent(out) | :: | pt(ldpt,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldpt | |||
| real(kind=sp), | intent(inout) | :: | c(ldc,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldc | |||
| real(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
ZGBBRD reduces a complex general m-by-n band matrix A to real upper bidiagonal form B by a unitary transformation: QH * A * P = B. The routine computes B, and optionally forms Q or PH, or computes Q*HC for a given matrix C.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | vect | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | ncc | |||
| integer(kind=ilp), | intent(in) | :: | kl | |||
| integer(kind=ilp), | intent(in) | :: | ku | |||
| complex(kind=dp), | intent(inout) | :: | ab(ldab,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldab | |||
| real(kind=dp), | intent(out) | :: | d(*) | |||
| real(kind=dp), | intent(out) | :: | e(*) | |||
| complex(kind=dp), | intent(out) | :: | q(ldq,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldq | |||
| complex(kind=dp), | intent(out) | :: | pt(ldpt,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldpt | |||
| complex(kind=dp), | intent(inout) | :: | c(ldc,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldc | |||
| complex(kind=dp), | intent(out) | :: | work(*) | |||
| real(kind=dp), | intent(out) | :: | rwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
GBCON estimates the reciprocal of the condition number of a complex general band matrix A, in either the 1-norm or the infinity-norm, using the LU factorization computed by CGBTRF. An estimate is obtained for norm(inv(A)), and the reciprocal of the condition number is computed as RCOND = 1 / ( norm(A) * norm(inv(A)) ).
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | norm | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | kl | |||
| integer(kind=ilp), | intent(in) | :: | ku | |||
| complex(kind=sp), | intent(in) | :: | ab(ldab,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldab | |||
| integer(kind=ilp), | intent(in) | :: | ipiv(*) | |||
| real(kind=sp), | intent(in) | :: | anorm | |||
| real(kind=sp), | intent(out) | :: | rcond | |||
| complex(kind=sp), | intent(out) | :: | work(*) | |||
| real(kind=sp), | intent(out) | :: | rwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | norm | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | kl | |||
| integer(kind=ilp), | intent(in) | :: | ku | |||
| real(kind=dp), | intent(in) | :: | ab(ldab,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldab | |||
| integer(kind=ilp), | intent(in) | :: | ipiv(*) | |||
| real(kind=dp), | intent(in) | :: | anorm | |||
| real(kind=dp), | intent(out) | :: | rcond | |||
| real(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | iwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | norm | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | kl | |||
| integer(kind=ilp), | intent(in) | :: | ku | |||
| real(kind=sp), | intent(in) | :: | ab(ldab,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldab | |||
| integer(kind=ilp), | intent(in) | :: | ipiv(*) | |||
| real(kind=sp), | intent(in) | :: | anorm | |||
| real(kind=sp), | intent(out) | :: | rcond | |||
| real(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | iwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | norm | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | kl | |||
| integer(kind=ilp), | intent(in) | :: | ku | |||
| complex(kind=dp), | intent(in) | :: | ab(ldab,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldab | |||
| integer(kind=ilp), | intent(in) | :: | ipiv(*) | |||
| real(kind=dp), | intent(in) | :: | anorm | |||
| real(kind=dp), | intent(out) | :: | rcond | |||
| complex(kind=dp), | intent(out) | :: | work(*) | |||
| real(kind=dp), | intent(out) | :: | rwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
CGBCON estimates the reciprocal of the condition number of a complex general band matrix A, in either the 1-norm or the infinity-norm, using the LU factorization computed by CGBTRF. An estimate is obtained for norm(inv(A)), and the reciprocal of the condition number is computed as RCOND = 1 / ( norm(A) * norm(inv(A)) ).
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | norm | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | kl | |||
| integer(kind=ilp), | intent(in) | :: | ku | |||
| complex(kind=sp), | intent(in) | :: | ab(ldab,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldab | |||
| integer(kind=ilp), | intent(in) | :: | ipiv(*) | |||
| real(kind=sp), | intent(in) | :: | anorm | |||
| real(kind=sp), | intent(out) | :: | rcond | |||
| complex(kind=sp), | intent(out) | :: | work(*) | |||
| real(kind=sp), | intent(out) | :: | rwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
DGBCON estimates the reciprocal of the condition number of a real general band matrix A, in either the 1-norm or the infinity-norm, using the LU factorization computed by DGBTRF. An estimate is obtained for norm(inv(A)), and the reciprocal of the condition number is computed as RCOND = 1 / ( norm(A) * norm(inv(A)) ).
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | norm | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | kl | |||
| integer(kind=ilp), | intent(in) | :: | ku | |||
| real(kind=dp), | intent(in) | :: | ab(ldab,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldab | |||
| integer(kind=ilp), | intent(in) | :: | ipiv(*) | |||
| real(kind=dp), | intent(in) | :: | anorm | |||
| real(kind=dp), | intent(out) | :: | rcond | |||
| real(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | iwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
SGBCON estimates the reciprocal of the condition number of a real general band matrix A, in either the 1-norm or the infinity-norm, using the LU factorization computed by SGBTRF. An estimate is obtained for norm(inv(A)), and the reciprocal of the condition number is computed as RCOND = 1 / ( norm(A) * norm(inv(A)) ).
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | norm | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | kl | |||
| integer(kind=ilp), | intent(in) | :: | ku | |||
| real(kind=sp), | intent(in) | :: | ab(ldab,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldab | |||
| integer(kind=ilp), | intent(in) | :: | ipiv(*) | |||
| real(kind=sp), | intent(in) | :: | anorm | |||
| real(kind=sp), | intent(out) | :: | rcond | |||
| real(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | iwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
ZGBCON estimates the reciprocal of the condition number of a complex general band matrix A, in either the 1-norm or the infinity-norm, using the LU factorization computed by ZGBTRF. An estimate is obtained for norm(inv(A)), and the reciprocal of the condition number is computed as RCOND = 1 / ( norm(A) * norm(inv(A)) ).
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | norm | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | kl | |||
| integer(kind=ilp), | intent(in) | :: | ku | |||
| complex(kind=dp), | intent(in) | :: | ab(ldab,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldab | |||
| integer(kind=ilp), | intent(in) | :: | ipiv(*) | |||
| real(kind=dp), | intent(in) | :: | anorm | |||
| real(kind=dp), | intent(out) | :: | rcond | |||
| complex(kind=dp), | intent(out) | :: | work(*) | |||
| real(kind=dp), | intent(out) | :: | rwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
GBEQU computes row and column scalings intended to equilibrate an M-by-N band matrix A and reduce its condition number. R returns the row scale factors and C the column scale factors, chosen to try to make the largest element in each row and column of the matrix B with elements B(i,j)=R(i)A(i,j)C(j) have absolute value 1. R(i) and C(j) are restricted to be between SMLNUM = smallest safe number and BIGNUM = largest safe number. Use of these scaling factors is not guaranteed to reduce the condition number of A but works well in practice.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | kl | |||
| integer(kind=ilp), | intent(in) | :: | ku | |||
| complex(kind=sp), | intent(in) | :: | ab(ldab,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldab | |||
| real(kind=sp), | intent(out) | :: | r(*) | |||
| real(kind=sp), | intent(out) | :: | c(*) | |||
| real(kind=sp), | intent(out) | :: | rowcnd | |||
| real(kind=sp), | intent(out) | :: | colcnd | |||
| real(kind=sp), | intent(out) | :: | amax | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | kl | |||
| integer(kind=ilp), | intent(in) | :: | ku | |||
| real(kind=dp), | intent(in) | :: | ab(ldab,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldab | |||
| real(kind=dp), | intent(out) | :: | r(*) | |||
| real(kind=dp), | intent(out) | :: | c(*) | |||
| real(kind=dp), | intent(out) | :: | rowcnd | |||
| real(kind=dp), | intent(out) | :: | colcnd | |||
| real(kind=dp), | intent(out) | :: | amax | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | kl | |||
| integer(kind=ilp), | intent(in) | :: | ku | |||
| real(kind=sp), | intent(in) | :: | ab(ldab,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldab | |||
| real(kind=sp), | intent(out) | :: | r(*) | |||
| real(kind=sp), | intent(out) | :: | c(*) | |||
| real(kind=sp), | intent(out) | :: | rowcnd | |||
| real(kind=sp), | intent(out) | :: | colcnd | |||
| real(kind=sp), | intent(out) | :: | amax | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | kl | |||
| integer(kind=ilp), | intent(in) | :: | ku | |||
| complex(kind=dp), | intent(in) | :: | ab(ldab,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldab | |||
| real(kind=dp), | intent(out) | :: | r(*) | |||
| real(kind=dp), | intent(out) | :: | c(*) | |||
| real(kind=dp), | intent(out) | :: | rowcnd | |||
| real(kind=dp), | intent(out) | :: | colcnd | |||
| real(kind=dp), | intent(out) | :: | amax | |||
| integer(kind=ilp), | intent(out) | :: | info |
CGBEQU computes row and column scalings intended to equilibrate an M-by-N band matrix A and reduce its condition number. R returns the row scale factors and C the column scale factors, chosen to try to make the largest element in each row and column of the matrix B with elements B(i,j)=R(i)A(i,j)C(j) have absolute value 1. R(i) and C(j) are restricted to be between SMLNUM = smallest safe number and BIGNUM = largest safe number. Use of these scaling factors is not guaranteed to reduce the condition number of A but works well in practice.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | kl | |||
| integer(kind=ilp), | intent(in) | :: | ku | |||
| complex(kind=sp), | intent(in) | :: | ab(ldab,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldab | |||
| real(kind=sp), | intent(out) | :: | r(*) | |||
| real(kind=sp), | intent(out) | :: | c(*) | |||
| real(kind=sp), | intent(out) | :: | rowcnd | |||
| real(kind=sp), | intent(out) | :: | colcnd | |||
| real(kind=sp), | intent(out) | :: | amax | |||
| integer(kind=ilp), | intent(out) | :: | info |
DGBEQU computes row and column scalings intended to equilibrate an M-by-N band matrix A and reduce its condition number. R returns the row scale factors and C the column scale factors, chosen to try to make the largest element in each row and column of the matrix B with elements B(i,j)=R(i)A(i,j)C(j) have absolute value 1. R(i) and C(j) are restricted to be between SMLNUM = smallest safe number and BIGNUM = largest safe number. Use of these scaling factors is not guaranteed to reduce the condition number of A but works well in practice.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | kl | |||
| integer(kind=ilp), | intent(in) | :: | ku | |||
| real(kind=dp), | intent(in) | :: | ab(ldab,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldab | |||
| real(kind=dp), | intent(out) | :: | r(*) | |||
| real(kind=dp), | intent(out) | :: | c(*) | |||
| real(kind=dp), | intent(out) | :: | rowcnd | |||
| real(kind=dp), | intent(out) | :: | colcnd | |||
| real(kind=dp), | intent(out) | :: | amax | |||
| integer(kind=ilp), | intent(out) | :: | info |
SGBEQU computes row and column scalings intended to equilibrate an M-by-N band matrix A and reduce its condition number. R returns the row scale factors and C the column scale factors, chosen to try to make the largest element in each row and column of the matrix B with elements B(i,j)=R(i)A(i,j)C(j) have absolute value 1. R(i) and C(j) are restricted to be between SMLNUM = smallest safe number and BIGNUM = largest safe number. Use of these scaling factors is not guaranteed to reduce the condition number of A but works well in practice.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | kl | |||
| integer(kind=ilp), | intent(in) | :: | ku | |||
| real(kind=sp), | intent(in) | :: | ab(ldab,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldab | |||
| real(kind=sp), | intent(out) | :: | r(*) | |||
| real(kind=sp), | intent(out) | :: | c(*) | |||
| real(kind=sp), | intent(out) | :: | rowcnd | |||
| real(kind=sp), | intent(out) | :: | colcnd | |||
| real(kind=sp), | intent(out) | :: | amax | |||
| integer(kind=ilp), | intent(out) | :: | info |
ZGBEQU computes row and column scalings intended to equilibrate an M-by-N band matrix A and reduce its condition number. R returns the row scale factors and C the column scale factors, chosen to try to make the largest element in each row and column of the matrix B with elements B(i,j)=R(i)A(i,j)C(j) have absolute value 1. R(i) and C(j) are restricted to be between SMLNUM = smallest safe number and BIGNUM = largest safe number. Use of these scaling factors is not guaranteed to reduce the condition number of A but works well in practice.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | kl | |||
| integer(kind=ilp), | intent(in) | :: | ku | |||
| complex(kind=dp), | intent(in) | :: | ab(ldab,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldab | |||
| real(kind=dp), | intent(out) | :: | r(*) | |||
| real(kind=dp), | intent(out) | :: | c(*) | |||
| real(kind=dp), | intent(out) | :: | rowcnd | |||
| real(kind=dp), | intent(out) | :: | colcnd | |||
| real(kind=dp), | intent(out) | :: | amax | |||
| integer(kind=ilp), | intent(out) | :: | info |
GBEQUB computes row and column scalings intended to equilibrate an M-by-N matrix A and reduce its condition number. R returns the row scale factors and C the column scale factors, chosen to try to make the largest element in each row and column of the matrix B with elements B(i,j)=R(i)A(i,j)C(j) have an absolute value of at most the radix. R(i) and C(j) are restricted to be a power of the radix between SMLNUM = smallest safe number and BIGNUM = largest safe number. Use of these scaling factors is not guaranteed to reduce the condition number of A but works well in practice. This routine differs from CGEEQU by restricting the scaling factors to a power of the radix. Barring over- and underflow, scaling by these factors introduces no additional rounding errors. However, the scaled entries' magnitudes are no longer approximately 1 but lie between sqrt(radix) and 1/sqrt(radix).
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | kl | |||
| integer(kind=ilp), | intent(in) | :: | ku | |||
| complex(kind=sp), | intent(in) | :: | ab(ldab,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldab | |||
| real(kind=sp), | intent(out) | :: | r(*) | |||
| real(kind=sp), | intent(out) | :: | c(*) | |||
| real(kind=sp), | intent(out) | :: | rowcnd | |||
| real(kind=sp), | intent(out) | :: | colcnd | |||
| real(kind=sp), | intent(out) | :: | amax | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | kl | |||
| integer(kind=ilp), | intent(in) | :: | ku | |||
| real(kind=dp), | intent(in) | :: | ab(ldab,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldab | |||
| real(kind=dp), | intent(out) | :: | r(*) | |||
| real(kind=dp), | intent(out) | :: | c(*) | |||
| real(kind=dp), | intent(out) | :: | rowcnd | |||
| real(kind=dp), | intent(out) | :: | colcnd | |||
| real(kind=dp), | intent(out) | :: | amax | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | kl | |||
| integer(kind=ilp), | intent(in) | :: | ku | |||
| real(kind=sp), | intent(in) | :: | ab(ldab,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldab | |||
| real(kind=sp), | intent(out) | :: | r(*) | |||
| real(kind=sp), | intent(out) | :: | c(*) | |||
| real(kind=sp), | intent(out) | :: | rowcnd | |||
| real(kind=sp), | intent(out) | :: | colcnd | |||
| real(kind=sp), | intent(out) | :: | amax | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | kl | |||
| integer(kind=ilp), | intent(in) | :: | ku | |||
| complex(kind=dp), | intent(in) | :: | ab(ldab,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldab | |||
| real(kind=dp), | intent(out) | :: | r(*) | |||
| real(kind=dp), | intent(out) | :: | c(*) | |||
| real(kind=dp), | intent(out) | :: | rowcnd | |||
| real(kind=dp), | intent(out) | :: | colcnd | |||
| real(kind=dp), | intent(out) | :: | amax | |||
| integer(kind=ilp), | intent(out) | :: | info |
CGBEQUB computes row and column scalings intended to equilibrate an M-by-N matrix A and reduce its condition number. R returns the row scale factors and C the column scale factors, chosen to try to make the largest element in each row and column of the matrix B with elements B(i,j)=R(i)A(i,j)C(j) have an absolute value of at most the radix. R(i) and C(j) are restricted to be a power of the radix between SMLNUM = smallest safe number and BIGNUM = largest safe number. Use of these scaling factors is not guaranteed to reduce the condition number of A but works well in practice. This routine differs from CGEEQU by restricting the scaling factors to a power of the radix. Barring over- and underflow, scaling by these factors introduces no additional rounding errors. However, the scaled entries' magnitudes are no longer approximately 1 but lie between sqrt(radix) and 1/sqrt(radix).
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | kl | |||
| integer(kind=ilp), | intent(in) | :: | ku | |||
| complex(kind=sp), | intent(in) | :: | ab(ldab,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldab | |||
| real(kind=sp), | intent(out) | :: | r(*) | |||
| real(kind=sp), | intent(out) | :: | c(*) | |||
| real(kind=sp), | intent(out) | :: | rowcnd | |||
| real(kind=sp), | intent(out) | :: | colcnd | |||
| real(kind=sp), | intent(out) | :: | amax | |||
| integer(kind=ilp), | intent(out) | :: | info |
DGBEQUB computes row and column scalings intended to equilibrate an M-by-N matrix A and reduce its condition number. R returns the row scale factors and C the column scale factors, chosen to try to make the largest element in each row and column of the matrix B with elements B(i,j)=R(i)A(i,j)C(j) have an absolute value of at most the radix. R(i) and C(j) are restricted to be a power of the radix between SMLNUM = smallest safe number and BIGNUM = largest safe number. Use of these scaling factors is not guaranteed to reduce the condition number of A but works well in practice. This routine differs from DGEEQU by restricting the scaling factors to a power of the radix. Barring over- and underflow, scaling by these factors introduces no additional rounding errors. However, the scaled entries' magnitudes are no longer approximately 1 but lie between sqrt(radix) and 1/sqrt(radix).
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | kl | |||
| integer(kind=ilp), | intent(in) | :: | ku | |||
| real(kind=dp), | intent(in) | :: | ab(ldab,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldab | |||
| real(kind=dp), | intent(out) | :: | r(*) | |||
| real(kind=dp), | intent(out) | :: | c(*) | |||
| real(kind=dp), | intent(out) | :: | rowcnd | |||
| real(kind=dp), | intent(out) | :: | colcnd | |||
| real(kind=dp), | intent(out) | :: | amax | |||
| integer(kind=ilp), | intent(out) | :: | info |
SGBEQUB computes row and column scalings intended to equilibrate an M-by-N matrix A and reduce its condition number. R returns the row scale factors and C the column scale factors, chosen to try to make the largest element in each row and column of the matrix B with elements B(i,j)=R(i)A(i,j)C(j) have an absolute value of at most the radix. R(i) and C(j) are restricted to be a power of the radix between SMLNUM = smallest safe number and BIGNUM = largest safe number. Use of these scaling factors is not guaranteed to reduce the condition number of A but works well in practice. This routine differs from SGEEQU by restricting the scaling factors to a power of the radix. Barring over- and underflow, scaling by these factors introduces no additional rounding errors. However, the scaled entries' magnitudes are no longer approximately 1 but lie between sqrt(radix) and 1/sqrt(radix).
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | kl | |||
| integer(kind=ilp), | intent(in) | :: | ku | |||
| real(kind=sp), | intent(in) | :: | ab(ldab,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldab | |||
| real(kind=sp), | intent(out) | :: | r(*) | |||
| real(kind=sp), | intent(out) | :: | c(*) | |||
| real(kind=sp), | intent(out) | :: | rowcnd | |||
| real(kind=sp), | intent(out) | :: | colcnd | |||
| real(kind=sp), | intent(out) | :: | amax | |||
| integer(kind=ilp), | intent(out) | :: | info |
ZGBEQUB computes row and column scalings intended to equilibrate an M-by-N matrix A and reduce its condition number. R returns the row scale factors and C the column scale factors, chosen to try to make the largest element in each row and column of the matrix B with elements B(i,j)=R(i)A(i,j)C(j) have an absolute value of at most the radix. R(i) and C(j) are restricted to be a power of the radix between SMLNUM = smallest safe number and BIGNUM = largest safe number. Use of these scaling factors is not guaranteed to reduce the condition number of A but works well in practice. This routine differs from ZGEEQU by restricting the scaling factors to a power of the radix. Barring over- and underflow, scaling by these factors introduces no additional rounding errors. However, the scaled entries' magnitudes are no longer approximately 1 but lie between sqrt(radix) and 1/sqrt(radix).
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | kl | |||
| integer(kind=ilp), | intent(in) | :: | ku | |||
| complex(kind=dp), | intent(in) | :: | ab(ldab,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldab | |||
| real(kind=dp), | intent(out) | :: | r(*) | |||
| real(kind=dp), | intent(out) | :: | c(*) | |||
| real(kind=dp), | intent(out) | :: | rowcnd | |||
| real(kind=dp), | intent(out) | :: | colcnd | |||
| real(kind=dp), | intent(out) | :: | amax | |||
| integer(kind=ilp), | intent(out) | :: | info |
GBRFS improves the computed solution to a system of linear equations when the coefficient matrix is banded, and provides error bounds and backward error estimates for the solution.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | trans | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | kl | |||
| integer(kind=ilp), | intent(in) | :: | ku | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| complex(kind=sp), | intent(in) | :: | ab(ldab,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldab | |||
| complex(kind=sp), | intent(in) | :: | afb(ldafb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldafb | |||
| integer(kind=ilp), | intent(in) | :: | ipiv(*) | |||
| complex(kind=sp), | intent(in) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| complex(kind=sp), | intent(inout) | :: | x(ldx,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldx | |||
| real(kind=sp), | intent(out) | :: | ferr(*) | |||
| real(kind=sp), | intent(out) | :: | berr(*) | |||
| complex(kind=sp), | intent(out) | :: | work(*) | |||
| real(kind=sp), | intent(out) | :: | rwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | trans | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | kl | |||
| integer(kind=ilp), | intent(in) | :: | ku | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| real(kind=dp), | intent(in) | :: | ab(ldab,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldab | |||
| real(kind=dp), | intent(in) | :: | afb(ldafb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldafb | |||
| integer(kind=ilp), | intent(in) | :: | ipiv(*) | |||
| real(kind=dp), | intent(in) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| real(kind=dp), | intent(inout) | :: | x(ldx,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldx | |||
| real(kind=dp), | intent(out) | :: | ferr(*) | |||
| real(kind=dp), | intent(out) | :: | berr(*) | |||
| real(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | iwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | trans | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | kl | |||
| integer(kind=ilp), | intent(in) | :: | ku | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| real(kind=sp), | intent(in) | :: | ab(ldab,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldab | |||
| real(kind=sp), | intent(in) | :: | afb(ldafb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldafb | |||
| integer(kind=ilp), | intent(in) | :: | ipiv(*) | |||
| real(kind=sp), | intent(in) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| real(kind=sp), | intent(inout) | :: | x(ldx,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldx | |||
| real(kind=sp), | intent(out) | :: | ferr(*) | |||
| real(kind=sp), | intent(out) | :: | berr(*) | |||
| real(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | iwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | trans | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | kl | |||
| integer(kind=ilp), | intent(in) | :: | ku | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| complex(kind=dp), | intent(in) | :: | ab(ldab,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldab | |||
| complex(kind=dp), | intent(in) | :: | afb(ldafb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldafb | |||
| integer(kind=ilp), | intent(in) | :: | ipiv(*) | |||
| complex(kind=dp), | intent(in) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| complex(kind=dp), | intent(inout) | :: | x(ldx,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldx | |||
| real(kind=dp), | intent(out) | :: | ferr(*) | |||
| real(kind=dp), | intent(out) | :: | berr(*) | |||
| complex(kind=dp), | intent(out) | :: | work(*) | |||
| real(kind=dp), | intent(out) | :: | rwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
CGBRFS improves the computed solution to a system of linear equations when the coefficient matrix is banded, and provides error bounds and backward error estimates for the solution.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | trans | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | kl | |||
| integer(kind=ilp), | intent(in) | :: | ku | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| complex(kind=sp), | intent(in) | :: | ab(ldab,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldab | |||
| complex(kind=sp), | intent(in) | :: | afb(ldafb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldafb | |||
| integer(kind=ilp), | intent(in) | :: | ipiv(*) | |||
| complex(kind=sp), | intent(in) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| complex(kind=sp), | intent(inout) | :: | x(ldx,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldx | |||
| real(kind=sp), | intent(out) | :: | ferr(*) | |||
| real(kind=sp), | intent(out) | :: | berr(*) | |||
| complex(kind=sp), | intent(out) | :: | work(*) | |||
| real(kind=sp), | intent(out) | :: | rwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
DGBRFS improves the computed solution to a system of linear equations when the coefficient matrix is banded, and provides error bounds and backward error estimates for the solution.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | trans | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | kl | |||
| integer(kind=ilp), | intent(in) | :: | ku | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| real(kind=dp), | intent(in) | :: | ab(ldab,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldab | |||
| real(kind=dp), | intent(in) | :: | afb(ldafb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldafb | |||
| integer(kind=ilp), | intent(in) | :: | ipiv(*) | |||
| real(kind=dp), | intent(in) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| real(kind=dp), | intent(inout) | :: | x(ldx,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldx | |||
| real(kind=dp), | intent(out) | :: | ferr(*) | |||
| real(kind=dp), | intent(out) | :: | berr(*) | |||
| real(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | iwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
SGBRFS improves the computed solution to a system of linear equations when the coefficient matrix is banded, and provides error bounds and backward error estimates for the solution.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | trans | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | kl | |||
| integer(kind=ilp), | intent(in) | :: | ku | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| real(kind=sp), | intent(in) | :: | ab(ldab,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldab | |||
| real(kind=sp), | intent(in) | :: | afb(ldafb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldafb | |||
| integer(kind=ilp), | intent(in) | :: | ipiv(*) | |||
| real(kind=sp), | intent(in) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| real(kind=sp), | intent(inout) | :: | x(ldx,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldx | |||
| real(kind=sp), | intent(out) | :: | ferr(*) | |||
| real(kind=sp), | intent(out) | :: | berr(*) | |||
| real(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | iwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
ZGBRFS improves the computed solution to a system of linear equations when the coefficient matrix is banded, and provides error bounds and backward error estimates for the solution.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | trans | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | kl | |||
| integer(kind=ilp), | intent(in) | :: | ku | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| complex(kind=dp), | intent(in) | :: | ab(ldab,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldab | |||
| complex(kind=dp), | intent(in) | :: | afb(ldafb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldafb | |||
| integer(kind=ilp), | intent(in) | :: | ipiv(*) | |||
| complex(kind=dp), | intent(in) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| complex(kind=dp), | intent(inout) | :: | x(ldx,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldx | |||
| real(kind=dp), | intent(out) | :: | ferr(*) | |||
| real(kind=dp), | intent(out) | :: | berr(*) | |||
| complex(kind=dp), | intent(out) | :: | work(*) | |||
| real(kind=dp), | intent(out) | :: | rwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
GBSV computes the solution to a complex system of linear equations A * X = B, where A is a band matrix of order N with KL subdiagonals and KU superdiagonals, and X and B are N-by-NRHS matrices. The LU decomposition with partial pivoting and row interchanges is used to factor A as A = L * U, where L is a product of permutation and unit lower triangular matrices with KL subdiagonals, and U is upper triangular with KL+KU superdiagonals. The factored form of A is then used to solve the system of equations A * X = B.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | kl | |||
| integer(kind=ilp), | intent(in) | :: | ku | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| complex(kind=sp), | intent(inout) | :: | ab(ldab,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldab | |||
| integer(kind=ilp), | intent(out) | :: | ipiv(*) | |||
| complex(kind=sp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | kl | |||
| integer(kind=ilp), | intent(in) | :: | ku | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| real(kind=dp), | intent(inout) | :: | ab(ldab,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldab | |||
| integer(kind=ilp), | intent(out) | :: | ipiv(*) | |||
| real(kind=dp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | kl | |||
| integer(kind=ilp), | intent(in) | :: | ku | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| real(kind=sp), | intent(inout) | :: | ab(ldab,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldab | |||
| integer(kind=ilp), | intent(out) | :: | ipiv(*) | |||
| real(kind=sp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | kl | |||
| integer(kind=ilp), | intent(in) | :: | ku | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| complex(kind=dp), | intent(inout) | :: | ab(ldab,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldab | |||
| integer(kind=ilp), | intent(out) | :: | ipiv(*) | |||
| complex(kind=dp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| integer(kind=ilp), | intent(out) | :: | info |
CGBSV computes the solution to a complex system of linear equations A * X = B, where A is a band matrix of order N with KL subdiagonals and KU superdiagonals, and X and B are N-by-NRHS matrices. The LU decomposition with partial pivoting and row interchanges is used to factor A as A = L * U, where L is a product of permutation and unit lower triangular matrices with KL subdiagonals, and U is upper triangular with KL+KU superdiagonals. The factored form of A is then used to solve the system of equations A * X = B.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | kl | |||
| integer(kind=ilp), | intent(in) | :: | ku | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| complex(kind=sp), | intent(inout) | :: | ab(ldab,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldab | |||
| integer(kind=ilp), | intent(out) | :: | ipiv(*) | |||
| complex(kind=sp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| integer(kind=ilp), | intent(out) | :: | info |
DGBSV computes the solution to a real system of linear equations A * X = B, where A is a band matrix of order N with KL subdiagonals and KU superdiagonals, and X and B are N-by-NRHS matrices. The LU decomposition with partial pivoting and row interchanges is used to factor A as A = L * U, where L is a product of permutation and unit lower triangular matrices with KL subdiagonals, and U is upper triangular with KL+KU superdiagonals. The factored form of A is then used to solve the system of equations A * X = B.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | kl | |||
| integer(kind=ilp), | intent(in) | :: | ku | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| real(kind=dp), | intent(inout) | :: | ab(ldab,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldab | |||
| integer(kind=ilp), | intent(out) | :: | ipiv(*) | |||
| real(kind=dp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| integer(kind=ilp), | intent(out) | :: | info |
SGBSV computes the solution to a real system of linear equations A * X = B, where A is a band matrix of order N with KL subdiagonals and KU superdiagonals, and X and B are N-by-NRHS matrices. The LU decomposition with partial pivoting and row interchanges is used to factor A as A = L * U, where L is a product of permutation and unit lower triangular matrices with KL subdiagonals, and U is upper triangular with KL+KU superdiagonals. The factored form of A is then used to solve the system of equations A * X = B.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | kl | |||
| integer(kind=ilp), | intent(in) | :: | ku | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| real(kind=sp), | intent(inout) | :: | ab(ldab,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldab | |||
| integer(kind=ilp), | intent(out) | :: | ipiv(*) | |||
| real(kind=sp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| integer(kind=ilp), | intent(out) | :: | info |
ZGBSV computes the solution to a complex system of linear equations A * X = B, where A is a band matrix of order N with KL subdiagonals and KU superdiagonals, and X and B are N-by-NRHS matrices. The LU decomposition with partial pivoting and row interchanges is used to factor A as A = L * U, where L is a product of permutation and unit lower triangular matrices with KL subdiagonals, and U is upper triangular with KL+KU superdiagonals. The factored form of A is then used to solve the system of equations A * X = B.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | kl | |||
| integer(kind=ilp), | intent(in) | :: | ku | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| complex(kind=dp), | intent(inout) | :: | ab(ldab,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldab | |||
| integer(kind=ilp), | intent(out) | :: | ipiv(*) | |||
| complex(kind=dp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| integer(kind=ilp), | intent(out) | :: | info |
GBTRF computes an LU factorization of a complex m-by-n band matrix A using partial pivoting with row interchanges. This is the blocked version of the algorithm, calling Level 3 BLAS.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | kl | |||
| integer(kind=ilp), | intent(in) | :: | ku | |||
| complex(kind=sp), | intent(inout) | :: | ab(ldab,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldab | |||
| integer(kind=ilp), | intent(out) | :: | ipiv(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | kl | |||
| integer(kind=ilp), | intent(in) | :: | ku | |||
| real(kind=dp), | intent(inout) | :: | ab(ldab,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldab | |||
| integer(kind=ilp), | intent(out) | :: | ipiv(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | kl | |||
| integer(kind=ilp), | intent(in) | :: | ku | |||
| real(kind=sp), | intent(inout) | :: | ab(ldab,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldab | |||
| integer(kind=ilp), | intent(out) | :: | ipiv(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | kl | |||
| integer(kind=ilp), | intent(in) | :: | ku | |||
| complex(kind=dp), | intent(inout) | :: | ab(ldab,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldab | |||
| integer(kind=ilp), | intent(out) | :: | ipiv(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
CGBTRF computes an LU factorization of a complex m-by-n band matrix A using partial pivoting with row interchanges. This is the blocked version of the algorithm, calling Level 3 BLAS.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | kl | |||
| integer(kind=ilp), | intent(in) | :: | ku | |||
| complex(kind=sp), | intent(inout) | :: | ab(ldab,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldab | |||
| integer(kind=ilp), | intent(out) | :: | ipiv(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
DGBTRF computes an LU factorization of a real m-by-n band matrix A using partial pivoting with row interchanges. This is the blocked version of the algorithm, calling Level 3 BLAS.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | kl | |||
| integer(kind=ilp), | intent(in) | :: | ku | |||
| real(kind=dp), | intent(inout) | :: | ab(ldab,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldab | |||
| integer(kind=ilp), | intent(out) | :: | ipiv(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
SGBTRF computes an LU factorization of a real m-by-n band matrix A using partial pivoting with row interchanges. This is the blocked version of the algorithm, calling Level 3 BLAS.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | kl | |||
| integer(kind=ilp), | intent(in) | :: | ku | |||
| real(kind=sp), | intent(inout) | :: | ab(ldab,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldab | |||
| integer(kind=ilp), | intent(out) | :: | ipiv(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
ZGBTRF computes an LU factorization of a complex m-by-n band matrix A using partial pivoting with row interchanges. This is the blocked version of the algorithm, calling Level 3 BLAS.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | kl | |||
| integer(kind=ilp), | intent(in) | :: | ku | |||
| complex(kind=dp), | intent(inout) | :: | ab(ldab,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldab | |||
| integer(kind=ilp), | intent(out) | :: | ipiv(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
GBTRS solves a system of linear equations A * X = B, AT * X = B, or AH * X = B with a general band matrix A using the LU factorization computed by CGBTRF.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | trans | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | kl | |||
| integer(kind=ilp), | intent(in) | :: | ku | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| complex(kind=sp), | intent(in) | :: | ab(ldab,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldab | |||
| integer(kind=ilp), | intent(in) | :: | ipiv(*) | |||
| complex(kind=sp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | trans | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | kl | |||
| integer(kind=ilp), | intent(in) | :: | ku | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| real(kind=dp), | intent(in) | :: | ab(ldab,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldab | |||
| integer(kind=ilp), | intent(in) | :: | ipiv(*) | |||
| real(kind=dp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | trans | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | kl | |||
| integer(kind=ilp), | intent(in) | :: | ku | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| real(kind=sp), | intent(in) | :: | ab(ldab,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldab | |||
| integer(kind=ilp), | intent(in) | :: | ipiv(*) | |||
| real(kind=sp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | trans | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | kl | |||
| integer(kind=ilp), | intent(in) | :: | ku | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| complex(kind=dp), | intent(in) | :: | ab(ldab,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldab | |||
| integer(kind=ilp), | intent(in) | :: | ipiv(*) | |||
| complex(kind=dp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| integer(kind=ilp), | intent(out) | :: | info |
CGBTRS solves a system of linear equations A * X = B, AT * X = B, or AH * X = B with a general band matrix A using the LU factorization computed by CGBTRF.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | trans | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | kl | |||
| integer(kind=ilp), | intent(in) | :: | ku | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| complex(kind=sp), | intent(in) | :: | ab(ldab,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldab | |||
| integer(kind=ilp), | intent(in) | :: | ipiv(*) | |||
| complex(kind=sp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| integer(kind=ilp), | intent(out) | :: | info |
DGBTRS solves a system of linear equations A * X = B or A**T * X = B with a general band matrix A using the LU factorization computed by DGBTRF.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | trans | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | kl | |||
| integer(kind=ilp), | intent(in) | :: | ku | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| real(kind=dp), | intent(in) | :: | ab(ldab,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldab | |||
| integer(kind=ilp), | intent(in) | :: | ipiv(*) | |||
| real(kind=dp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| integer(kind=ilp), | intent(out) | :: | info |
SGBTRS solves a system of linear equations A * X = B or A**T * X = B with a general band matrix A using the LU factorization computed by SGBTRF.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | trans | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | kl | |||
| integer(kind=ilp), | intent(in) | :: | ku | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| real(kind=sp), | intent(in) | :: | ab(ldab,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldab | |||
| integer(kind=ilp), | intent(in) | :: | ipiv(*) | |||
| real(kind=sp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| integer(kind=ilp), | intent(out) | :: | info |
ZGBTRS solves a system of linear equations A * X = B, AT * X = B, or AH * X = B with a general band matrix A using the LU factorization computed by ZGBTRF.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | trans | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | kl | |||
| integer(kind=ilp), | intent(in) | :: | ku | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| complex(kind=dp), | intent(in) | :: | ab(ldab,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldab | |||
| integer(kind=ilp), | intent(in) | :: | ipiv(*) | |||
| complex(kind=dp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| integer(kind=ilp), | intent(out) | :: | info |
GEBAK forms the right or left eigenvectors of a complex general matrix by backward transformation on the computed eigenvectors of the balanced matrix output by CGEBAL.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | job | |||
| character, | intent(in) | :: | side | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | ilo | |||
| integer(kind=ilp), | intent(in) | :: | ihi | |||
| real(kind=sp), | intent(in) | :: | scale(*) | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| complex(kind=sp), | intent(inout) | :: | v(ldv,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldv | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | job | |||
| character, | intent(in) | :: | side | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | ilo | |||
| integer(kind=ilp), | intent(in) | :: | ihi | |||
| real(kind=dp), | intent(in) | :: | scale(*) | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| real(kind=dp), | intent(inout) | :: | v(ldv,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldv | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | job | |||
| character, | intent(in) | :: | side | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | ilo | |||
| integer(kind=ilp), | intent(in) | :: | ihi | |||
| real(kind=sp), | intent(in) | :: | scale(*) | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| real(kind=sp), | intent(inout) | :: | v(ldv,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldv | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | job | |||
| character, | intent(in) | :: | side | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | ilo | |||
| integer(kind=ilp), | intent(in) | :: | ihi | |||
| real(kind=dp), | intent(in) | :: | scale(*) | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| complex(kind=dp), | intent(inout) | :: | v(ldv,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldv | |||
| integer(kind=ilp), | intent(out) | :: | info |
CGEBAK forms the right or left eigenvectors of a complex general matrix by backward transformation on the computed eigenvectors of the balanced matrix output by CGEBAL.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | job | |||
| character, | intent(in) | :: | side | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | ilo | |||
| integer(kind=ilp), | intent(in) | :: | ihi | |||
| real(kind=sp), | intent(in) | :: | scale(*) | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| complex(kind=sp), | intent(inout) | :: | v(ldv,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldv | |||
| integer(kind=ilp), | intent(out) | :: | info |
DGEBAK forms the right or left eigenvectors of a real general matrix by backward transformation on the computed eigenvectors of the balanced matrix output by DGEBAL.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | job | |||
| character, | intent(in) | :: | side | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | ilo | |||
| integer(kind=ilp), | intent(in) | :: | ihi | |||
| real(kind=dp), | intent(in) | :: | scale(*) | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| real(kind=dp), | intent(inout) | :: | v(ldv,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldv | |||
| integer(kind=ilp), | intent(out) | :: | info |
SGEBAK forms the right or left eigenvectors of a real general matrix by backward transformation on the computed eigenvectors of the balanced matrix output by SGEBAL.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | job | |||
| character, | intent(in) | :: | side | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | ilo | |||
| integer(kind=ilp), | intent(in) | :: | ihi | |||
| real(kind=sp), | intent(in) | :: | scale(*) | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| real(kind=sp), | intent(inout) | :: | v(ldv,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldv | |||
| integer(kind=ilp), | intent(out) | :: | info |
ZGEBAK forms the right or left eigenvectors of a complex general matrix by backward transformation on the computed eigenvectors of the balanced matrix output by ZGEBAL.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | job | |||
| character, | intent(in) | :: | side | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | ilo | |||
| integer(kind=ilp), | intent(in) | :: | ihi | |||
| real(kind=dp), | intent(in) | :: | scale(*) | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| complex(kind=dp), | intent(inout) | :: | v(ldv,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldv | |||
| integer(kind=ilp), | intent(out) | :: | info |
GEBAL balances a general complex matrix A. This involves, first, permuting A by a similarity transformation to isolate eigenvalues in the first 1 to ILO-1 and last IHI+1 to N elements on the diagonal; and second, applying a diagonal similarity transformation to rows and columns ILO to IHI to make the rows and columns as close in norm as possible. Both steps are optional. Balancing may reduce the 1-norm of the matrix, and improve the accuracy of the computed eigenvalues and/or eigenvectors.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | job | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| integer(kind=ilp), | intent(out) | :: | ilo | |||
| integer(kind=ilp), | intent(out) | :: | ihi | |||
| real(kind=sp), | intent(out) | :: | scale(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | job | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| integer(kind=ilp), | intent(out) | :: | ilo | |||
| integer(kind=ilp), | intent(out) | :: | ihi | |||
| real(kind=dp), | intent(out) | :: | scale(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | job | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| integer(kind=ilp), | intent(out) | :: | ilo | |||
| integer(kind=ilp), | intent(out) | :: | ihi | |||
| real(kind=sp), | intent(out) | :: | scale(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | job | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| integer(kind=ilp), | intent(out) | :: | ilo | |||
| integer(kind=ilp), | intent(out) | :: | ihi | |||
| real(kind=dp), | intent(out) | :: | scale(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
CGEBAL balances a general complex matrix A. This involves, first, permuting A by a similarity transformation to isolate eigenvalues in the first 1 to ILO-1 and last IHI+1 to N elements on the diagonal; and second, applying a diagonal similarity transformation to rows and columns ILO to IHI to make the rows and columns as close in norm as possible. Both steps are optional. Balancing may reduce the 1-norm of the matrix, and improve the accuracy of the computed eigenvalues and/or eigenvectors.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | job | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| integer(kind=ilp), | intent(out) | :: | ilo | |||
| integer(kind=ilp), | intent(out) | :: | ihi | |||
| real(kind=sp), | intent(out) | :: | scale(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
DGEBAL balances a general real matrix A. This involves, first, permuting A by a similarity transformation to isolate eigenvalues in the first 1 to ILO-1 and last IHI+1 to N elements on the diagonal; and second, applying a diagonal similarity transformation to rows and columns ILO to IHI to make the rows and columns as close in norm as possible. Both steps are optional. Balancing may reduce the 1-norm of the matrix, and improve the accuracy of the computed eigenvalues and/or eigenvectors.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | job | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| integer(kind=ilp), | intent(out) | :: | ilo | |||
| integer(kind=ilp), | intent(out) | :: | ihi | |||
| real(kind=dp), | intent(out) | :: | scale(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
SGEBAL balances a general real matrix A. This involves, first, permuting A by a similarity transformation to isolate eigenvalues in the first 1 to ILO-1 and last IHI+1 to N elements on the diagonal; and second, applying a diagonal similarity transformation to rows and columns ILO to IHI to make the rows and columns as close in norm as possible. Both steps are optional. Balancing may reduce the 1-norm of the matrix, and improve the accuracy of the computed eigenvalues and/or eigenvectors.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | job | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| integer(kind=ilp), | intent(out) | :: | ilo | |||
| integer(kind=ilp), | intent(out) | :: | ihi | |||
| real(kind=sp), | intent(out) | :: | scale(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
ZGEBAL balances a general complex matrix A. This involves, first, permuting A by a similarity transformation to isolate eigenvalues in the first 1 to ILO-1 and last IHI+1 to N elements on the diagonal; and second, applying a diagonal similarity transformation to rows and columns ILO to IHI to make the rows and columns as close in norm as possible. Both steps are optional. Balancing may reduce the 1-norm of the matrix, and improve the accuracy of the computed eigenvalues and/or eigenvectors.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | job | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| integer(kind=ilp), | intent(out) | :: | ilo | |||
| integer(kind=ilp), | intent(out) | :: | ihi | |||
| real(kind=dp), | intent(out) | :: | scale(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
GEBRD reduces a general complex M-by-N matrix A to upper or lower bidiagonal form B by a unitary transformation: Q**H * A * P = B. If m >= n, B is upper bidiagonal; if m < n, B is lower bidiagonal.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=sp), | intent(out) | :: | d(*) | |||
| real(kind=sp), | intent(out) | :: | e(*) | |||
| complex(kind=sp), | intent(out) | :: | tauq(*) | |||
| complex(kind=sp), | intent(out) | :: | taup(*) | |||
| complex(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=dp), | intent(out) | :: | d(*) | |||
| real(kind=dp), | intent(out) | :: | e(*) | |||
| real(kind=dp), | intent(out) | :: | tauq(*) | |||
| real(kind=dp), | intent(out) | :: | taup(*) | |||
| real(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=sp), | intent(out) | :: | d(*) | |||
| real(kind=sp), | intent(out) | :: | e(*) | |||
| real(kind=sp), | intent(out) | :: | tauq(*) | |||
| real(kind=sp), | intent(out) | :: | taup(*) | |||
| real(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=dp), | intent(out) | :: | d(*) | |||
| real(kind=dp), | intent(out) | :: | e(*) | |||
| complex(kind=dp), | intent(out) | :: | tauq(*) | |||
| complex(kind=dp), | intent(out) | :: | taup(*) | |||
| complex(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
CGEBRD reduces a general complex M-by-N matrix A to upper or lower bidiagonal form B by a unitary transformation: Q**H * A * P = B. If m >= n, B is upper bidiagonal; if m < n, B is lower bidiagonal.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=sp), | intent(out) | :: | d(*) | |||
| real(kind=sp), | intent(out) | :: | e(*) | |||
| complex(kind=sp), | intent(out) | :: | tauq(*) | |||
| complex(kind=sp), | intent(out) | :: | taup(*) | |||
| complex(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
DGEBRD reduces a general real M-by-N matrix A to upper or lower bidiagonal form B by an orthogonal transformation: Q**T * A * P = B. If m >= n, B is upper bidiagonal; if m < n, B is lower bidiagonal.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=dp), | intent(out) | :: | d(*) | |||
| real(kind=dp), | intent(out) | :: | e(*) | |||
| real(kind=dp), | intent(out) | :: | tauq(*) | |||
| real(kind=dp), | intent(out) | :: | taup(*) | |||
| real(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
SGEBRD reduces a general real M-by-N matrix A to upper or lower bidiagonal form B by an orthogonal transformation: Q**T * A * P = B. If m >= n, B is upper bidiagonal; if m < n, B is lower bidiagonal.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=sp), | intent(out) | :: | d(*) | |||
| real(kind=sp), | intent(out) | :: | e(*) | |||
| real(kind=sp), | intent(out) | :: | tauq(*) | |||
| real(kind=sp), | intent(out) | :: | taup(*) | |||
| real(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
ZGEBRD reduces a general complex M-by-N matrix A to upper or lower bidiagonal form B by a unitary transformation: Q**H * A * P = B. If m >= n, B is upper bidiagonal; if m < n, B is lower bidiagonal.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=dp), | intent(out) | :: | d(*) | |||
| real(kind=dp), | intent(out) | :: | e(*) | |||
| complex(kind=dp), | intent(out) | :: | tauq(*) | |||
| complex(kind=dp), | intent(out) | :: | taup(*) | |||
| complex(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
GECON estimates the reciprocal of the condition number of a general complex matrix A, in either the 1-norm or the infinity-norm, using the LU factorization computed by CGETRF. An estimate is obtained for norm(inv(A)), and the reciprocal of the condition number is computed as RCOND = 1 / ( norm(A) * norm(inv(A)) ).
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | norm | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=sp), | intent(in) | :: | anorm | |||
| real(kind=sp), | intent(out) | :: | rcond | |||
| complex(kind=sp), | intent(out) | :: | work(*) | |||
| real(kind=sp), | intent(out) | :: | rwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | norm | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=dp), | intent(in) | :: | anorm | |||
| real(kind=dp), | intent(out) | :: | rcond | |||
| real(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | iwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | norm | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=sp), | intent(in) | :: | anorm | |||
| real(kind=sp), | intent(out) | :: | rcond | |||
| real(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | iwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | norm | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=dp), | intent(in) | :: | anorm | |||
| real(kind=dp), | intent(out) | :: | rcond | |||
| complex(kind=dp), | intent(out) | :: | work(*) | |||
| real(kind=dp), | intent(out) | :: | rwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
CGECON estimates the reciprocal of the condition number of a general complex matrix A, in either the 1-norm or the infinity-norm, using the LU factorization computed by CGETRF. An estimate is obtained for norm(inv(A)), and the reciprocal of the condition number is computed as RCOND = 1 / ( norm(A) * norm(inv(A)) ).
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | norm | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=sp), | intent(in) | :: | anorm | |||
| real(kind=sp), | intent(out) | :: | rcond | |||
| complex(kind=sp), | intent(out) | :: | work(*) | |||
| real(kind=sp), | intent(out) | :: | rwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
DGECON estimates the reciprocal of the condition number of a general real matrix A, in either the 1-norm or the infinity-norm, using the LU factorization computed by DGETRF. An estimate is obtained for norm(inv(A)), and the reciprocal of the condition number is computed as RCOND = 1 / ( norm(A) * norm(inv(A)) ).
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | norm | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=dp), | intent(in) | :: | anorm | |||
| real(kind=dp), | intent(out) | :: | rcond | |||
| real(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | iwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
SGECON estimates the reciprocal of the condition number of a general real matrix A, in either the 1-norm or the infinity-norm, using the LU factorization computed by SGETRF. An estimate is obtained for norm(inv(A)), and the reciprocal of the condition number is computed as RCOND = 1 / ( norm(A) * norm(inv(A)) ).
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | norm | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=sp), | intent(in) | :: | anorm | |||
| real(kind=sp), | intent(out) | :: | rcond | |||
| real(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | iwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
ZGECON estimates the reciprocal of the condition number of a general complex matrix A, in either the 1-norm or the infinity-norm, using the LU factorization computed by ZGETRF. An estimate is obtained for norm(inv(A)), and the reciprocal of the condition number is computed as RCOND = 1 / ( norm(A) * norm(inv(A)) ).
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | norm | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=dp), | intent(in) | :: | anorm | |||
| real(kind=dp), | intent(out) | :: | rcond | |||
| complex(kind=dp), | intent(out) | :: | work(*) | |||
| real(kind=dp), | intent(out) | :: | rwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
GEEQU computes row and column scalings intended to equilibrate an M-by-N matrix A and reduce its condition number. R returns the row scale factors and C the column scale factors, chosen to try to make the largest element in each row and column of the matrix B with elements B(i,j)=R(i)A(i,j)C(j) have absolute value 1. R(i) and C(j) are restricted to be between SMLNUM = smallest safe number and BIGNUM = largest safe number. Use of these scaling factors is not guaranteed to reduce the condition number of A but works well in practice.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=sp), | intent(in) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=sp), | intent(out) | :: | r(*) | |||
| real(kind=sp), | intent(out) | :: | c(*) | |||
| real(kind=sp), | intent(out) | :: | rowcnd | |||
| real(kind=sp), | intent(out) | :: | colcnd | |||
| real(kind=sp), | intent(out) | :: | amax | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=dp), | intent(in) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=dp), | intent(out) | :: | r(*) | |||
| real(kind=dp), | intent(out) | :: | c(*) | |||
| real(kind=dp), | intent(out) | :: | rowcnd | |||
| real(kind=dp), | intent(out) | :: | colcnd | |||
| real(kind=dp), | intent(out) | :: | amax | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=sp), | intent(in) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=sp), | intent(out) | :: | r(*) | |||
| real(kind=sp), | intent(out) | :: | c(*) | |||
| real(kind=sp), | intent(out) | :: | rowcnd | |||
| real(kind=sp), | intent(out) | :: | colcnd | |||
| real(kind=sp), | intent(out) | :: | amax | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=dp), | intent(in) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=dp), | intent(out) | :: | r(*) | |||
| real(kind=dp), | intent(out) | :: | c(*) | |||
| real(kind=dp), | intent(out) | :: | rowcnd | |||
| real(kind=dp), | intent(out) | :: | colcnd | |||
| real(kind=dp), | intent(out) | :: | amax | |||
| integer(kind=ilp), | intent(out) | :: | info |
CGEEQU computes row and column scalings intended to equilibrate an M-by-N matrix A and reduce its condition number. R returns the row scale factors and C the column scale factors, chosen to try to make the largest element in each row and column of the matrix B with elements B(i,j)=R(i)A(i,j)C(j) have absolute value 1. R(i) and C(j) are restricted to be between SMLNUM = smallest safe number and BIGNUM = largest safe number. Use of these scaling factors is not guaranteed to reduce the condition number of A but works well in practice.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=sp), | intent(in) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=sp), | intent(out) | :: | r(*) | |||
| real(kind=sp), | intent(out) | :: | c(*) | |||
| real(kind=sp), | intent(out) | :: | rowcnd | |||
| real(kind=sp), | intent(out) | :: | colcnd | |||
| real(kind=sp), | intent(out) | :: | amax | |||
| integer(kind=ilp), | intent(out) | :: | info |
DGEEQU computes row and column scalings intended to equilibrate an M-by-N matrix A and reduce its condition number. R returns the row scale factors and C the column scale factors, chosen to try to make the largest element in each row and column of the matrix B with elements B(i,j)=R(i)A(i,j)C(j) have absolute value 1. R(i) and C(j) are restricted to be between SMLNUM = smallest safe number and BIGNUM = largest safe number. Use of these scaling factors is not guaranteed to reduce the condition number of A but works well in practice.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=dp), | intent(in) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=dp), | intent(out) | :: | r(*) | |||
| real(kind=dp), | intent(out) | :: | c(*) | |||
| real(kind=dp), | intent(out) | :: | rowcnd | |||
| real(kind=dp), | intent(out) | :: | colcnd | |||
| real(kind=dp), | intent(out) | :: | amax | |||
| integer(kind=ilp), | intent(out) | :: | info |
SGEEQU computes row and column scalings intended to equilibrate an M-by-N matrix A and reduce its condition number. R returns the row scale factors and C the column scale factors, chosen to try to make the largest element in each row and column of the matrix B with elements B(i,j)=R(i)A(i,j)C(j) have absolute value 1. R(i) and C(j) are restricted to be between SMLNUM = smallest safe number and BIGNUM = largest safe number. Use of these scaling factors is not guaranteed to reduce the condition number of A but works well in practice.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=sp), | intent(in) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=sp), | intent(out) | :: | r(*) | |||
| real(kind=sp), | intent(out) | :: | c(*) | |||
| real(kind=sp), | intent(out) | :: | rowcnd | |||
| real(kind=sp), | intent(out) | :: | colcnd | |||
| real(kind=sp), | intent(out) | :: | amax | |||
| integer(kind=ilp), | intent(out) | :: | info |
ZGEEQU computes row and column scalings intended to equilibrate an M-by-N matrix A and reduce its condition number. R returns the row scale factors and C the column scale factors, chosen to try to make the largest element in each row and column of the matrix B with elements B(i,j)=R(i)A(i,j)C(j) have absolute value 1. R(i) and C(j) are restricted to be between SMLNUM = smallest safe number and BIGNUM = largest safe number. Use of these scaling factors is not guaranteed to reduce the condition number of A but works well in practice.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=dp), | intent(in) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=dp), | intent(out) | :: | r(*) | |||
| real(kind=dp), | intent(out) | :: | c(*) | |||
| real(kind=dp), | intent(out) | :: | rowcnd | |||
| real(kind=dp), | intent(out) | :: | colcnd | |||
| real(kind=dp), | intent(out) | :: | amax | |||
| integer(kind=ilp), | intent(out) | :: | info |
GEEQUB computes row and column scalings intended to equilibrate an M-by-N matrix A and reduce its condition number. R returns the row scale factors and C the column scale factors, chosen to try to make the largest element in each row and column of the matrix B with elements B(i,j)=R(i)A(i,j)C(j) have an absolute value of at most the radix. R(i) and C(j) are restricted to be a power of the radix between SMLNUM = smallest safe number and BIGNUM = largest safe number. Use of these scaling factors is not guaranteed to reduce the condition number of A but works well in practice. This routine differs from CGEEQU by restricting the scaling factors to a power of the radix. Barring over- and underflow, scaling by these factors introduces no additional rounding errors. However, the scaled entries' magnitudes are no longer approximately 1 but lie between sqrt(radix) and 1/sqrt(radix).
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=sp), | intent(in) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=sp), | intent(out) | :: | r(*) | |||
| real(kind=sp), | intent(out) | :: | c(*) | |||
| real(kind=sp), | intent(out) | :: | rowcnd | |||
| real(kind=sp), | intent(out) | :: | colcnd | |||
| real(kind=sp), | intent(out) | :: | amax | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=dp), | intent(in) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=dp), | intent(out) | :: | r(*) | |||
| real(kind=dp), | intent(out) | :: | c(*) | |||
| real(kind=dp), | intent(out) | :: | rowcnd | |||
| real(kind=dp), | intent(out) | :: | colcnd | |||
| real(kind=dp), | intent(out) | :: | amax | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=sp), | intent(in) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=sp), | intent(out) | :: | r(*) | |||
| real(kind=sp), | intent(out) | :: | c(*) | |||
| real(kind=sp), | intent(out) | :: | rowcnd | |||
| real(kind=sp), | intent(out) | :: | colcnd | |||
| real(kind=sp), | intent(out) | :: | amax | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=dp), | intent(in) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=dp), | intent(out) | :: | r(*) | |||
| real(kind=dp), | intent(out) | :: | c(*) | |||
| real(kind=dp), | intent(out) | :: | rowcnd | |||
| real(kind=dp), | intent(out) | :: | colcnd | |||
| real(kind=dp), | intent(out) | :: | amax | |||
| integer(kind=ilp), | intent(out) | :: | info |
CGEEQUB computes row and column scalings intended to equilibrate an M-by-N matrix A and reduce its condition number. R returns the row scale factors and C the column scale factors, chosen to try to make the largest element in each row and column of the matrix B with elements B(i,j)=R(i)A(i,j)C(j) have an absolute value of at most the radix. R(i) and C(j) are restricted to be a power of the radix between SMLNUM = smallest safe number and BIGNUM = largest safe number. Use of these scaling factors is not guaranteed to reduce the condition number of A but works well in practice. This routine differs from CGEEQU by restricting the scaling factors to a power of the radix. Barring over- and underflow, scaling by these factors introduces no additional rounding errors. However, the scaled entries' magnitudes are no longer approximately 1 but lie between sqrt(radix) and 1/sqrt(radix).
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=sp), | intent(in) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=sp), | intent(out) | :: | r(*) | |||
| real(kind=sp), | intent(out) | :: | c(*) | |||
| real(kind=sp), | intent(out) | :: | rowcnd | |||
| real(kind=sp), | intent(out) | :: | colcnd | |||
| real(kind=sp), | intent(out) | :: | amax | |||
| integer(kind=ilp), | intent(out) | :: | info |
DGEEQUB computes row and column scalings intended to equilibrate an M-by-N matrix A and reduce its condition number. R returns the row scale factors and C the column scale factors, chosen to try to make the largest element in each row and column of the matrix B with elements B(i,j)=R(i)A(i,j)C(j) have an absolute value of at most the radix. R(i) and C(j) are restricted to be a power of the radix between SMLNUM = smallest safe number and BIGNUM = largest safe number. Use of these scaling factors is not guaranteed to reduce the condition number of A but works well in practice. This routine differs from DGEEQU by restricting the scaling factors to a power of the radix. Barring over- and underflow, scaling by these factors introduces no additional rounding errors. However, the scaled entries' magnitudes are no longer approximately 1 but lie between sqrt(radix) and 1/sqrt(radix).
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=dp), | intent(in) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=dp), | intent(out) | :: | r(*) | |||
| real(kind=dp), | intent(out) | :: | c(*) | |||
| real(kind=dp), | intent(out) | :: | rowcnd | |||
| real(kind=dp), | intent(out) | :: | colcnd | |||
| real(kind=dp), | intent(out) | :: | amax | |||
| integer(kind=ilp), | intent(out) | :: | info |
SGEEQUB computes row and column scalings intended to equilibrate an M-by-N matrix A and reduce its condition number. R returns the row scale factors and C the column scale factors, chosen to try to make the largest element in each row and column of the matrix B with elements B(i,j)=R(i)A(i,j)C(j) have an absolute value of at most the radix. R(i) and C(j) are restricted to be a power of the radix between SMLNUM = smallest safe number and BIGNUM = largest safe number. Use of these scaling factors is not guaranteed to reduce the condition number of A but works well in practice. This routine differs from SGEEQU by restricting the scaling factors to a power of the radix. Barring over- and underflow, scaling by these factors introduces no additional rounding errors. However, the scaled entries' magnitudes are no longer approximately 1 but lie between sqrt(radix) and 1/sqrt(radix).
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=sp), | intent(in) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=sp), | intent(out) | :: | r(*) | |||
| real(kind=sp), | intent(out) | :: | c(*) | |||
| real(kind=sp), | intent(out) | :: | rowcnd | |||
| real(kind=sp), | intent(out) | :: | colcnd | |||
| real(kind=sp), | intent(out) | :: | amax | |||
| integer(kind=ilp), | intent(out) | :: | info |
ZGEEQUB computes row and column scalings intended to equilibrate an M-by-N matrix A and reduce its condition number. R returns the row scale factors and C the column scale factors, chosen to try to make the largest element in each row and column of the matrix B with elements B(i,j)=R(i)A(i,j)C(j) have an absolute value of at most the radix. R(i) and C(j) are restricted to be a power of the radix between SMLNUM = smallest safe number and BIGNUM = largest safe number. Use of these scaling factors is not guaranteed to reduce the condition number of A but works well in practice. This routine differs from ZGEEQU by restricting the scaling factors to a power of the radix. Barring over- and underflow, scaling by these factors introduces no additional rounding errors. However, the scaled entries' magnitudes are no longer approximately 1 but lie between sqrt(radix) and 1/sqrt(radix).
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=dp), | intent(in) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=dp), | intent(out) | :: | r(*) | |||
| real(kind=dp), | intent(out) | :: | c(*) | |||
| real(kind=dp), | intent(out) | :: | rowcnd | |||
| real(kind=dp), | intent(out) | :: | colcnd | |||
| real(kind=dp), | intent(out) | :: | amax | |||
| integer(kind=ilp), | intent(out) | :: | info |
GEES computes for an N-by-N complex nonsymmetric matrix A, the eigenvalues, the Schur form T, and, optionally, the matrix of Schur vectors Z. This gives the Schur factorization A = ZT(Z**H). Optionally, it also orders the eigenvalues on the diagonal of the Schur form so that selected eigenvalues are at the top left. The leading columns of Z then form an orthonormal basis for the invariant subspace corresponding to the selected eigenvalues. A complex matrix is in Schur form if it is upper triangular.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | jobvs | |||
| character, | intent(in) | :: | sort | |||
| procedure(stdlib_select_c) | :: | select | ||||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| integer(kind=ilp), | intent(out) | :: | sdim | |||
| complex(kind=sp), | intent(out) | :: | w(*) | |||
| complex(kind=sp), | intent(out) | :: | vs(ldvs,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldvs | |||
| complex(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| real(kind=sp), | intent(out) | :: | rwork(*) | |||
| logical(kind=lk), | intent(out) | :: | bwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | jobvs | |||
| character, | intent(in) | :: | sort | |||
| procedure(stdlib_select_d) | :: | select | ||||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| integer(kind=ilp), | intent(out) | :: | sdim | |||
| real(kind=dp), | intent(out) | :: | wr(*) | |||
| real(kind=dp), | intent(out) | :: | wi(*) | |||
| real(kind=dp), | intent(out) | :: | vs(ldvs,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldvs | |||
| real(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| logical(kind=lk), | intent(out) | :: | bwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | jobvs | |||
| character, | intent(in) | :: | sort | |||
| procedure(stdlib_select_s) | :: | select | ||||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| integer(kind=ilp), | intent(out) | :: | sdim | |||
| real(kind=sp), | intent(out) | :: | wr(*) | |||
| real(kind=sp), | intent(out) | :: | wi(*) | |||
| real(kind=sp), | intent(out) | :: | vs(ldvs,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldvs | |||
| real(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| logical(kind=lk), | intent(out) | :: | bwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | jobvs | |||
| character, | intent(in) | :: | sort | |||
| procedure(stdlib_select_z) | :: | select | ||||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| integer(kind=ilp), | intent(out) | :: | sdim | |||
| complex(kind=dp), | intent(out) | :: | w(*) | |||
| complex(kind=dp), | intent(out) | :: | vs(ldvs,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldvs | |||
| complex(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| real(kind=dp), | intent(out) | :: | rwork(*) | |||
| logical(kind=lk), | intent(out) | :: | bwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
CGEES computes for an N-by-N complex nonsymmetric matrix A, the eigenvalues, the Schur form T, and, optionally, the matrix of Schur vectors Z. This gives the Schur factorization A = ZT(Z**H). Optionally, it also orders the eigenvalues on the diagonal of the Schur form so that selected eigenvalues are at the top left. The leading columns of Z then form an orthonormal basis for the invariant subspace corresponding to the selected eigenvalues. A complex matrix is in Schur form if it is upper triangular.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | jobvs | |||
| character, | intent(in) | :: | sort | |||
| procedure(stdlib_select_c) | :: | select | ||||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| integer(kind=ilp), | intent(out) | :: | sdim | |||
| complex(kind=sp), | intent(out) | :: | w(*) | |||
| complex(kind=sp), | intent(out) | :: | vs(ldvs,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldvs | |||
| complex(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| real(kind=sp), | intent(out) | :: | rwork(*) | |||
| logical(kind=lk), | intent(out) | :: | bwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
DGEES computes for an N-by-N real nonsymmetric matrix A, the eigenvalues, the real Schur form T, and, optionally, the matrix of Schur vectors Z. This gives the Schur factorization A = ZT(Z*T). Optionally, it also orders the eigenvalues on the diagonal of the real Schur form so that selected eigenvalues are at the top left. The leading columns of Z then form an orthonormal basis for the invariant subspace corresponding to the selected eigenvalues. A matrix is in real Schur form if it is upper quasi-triangular with 1-by-1 and 2-by-2 blocks. 2-by-2 blocks will be standardized in the form [ a b ] [ c a ] where bc < 0. The eigenvalues of such a block are a +- sqrt(bc).
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | jobvs | |||
| character, | intent(in) | :: | sort | |||
| procedure(stdlib_select_d) | :: | select | ||||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| integer(kind=ilp), | intent(out) | :: | sdim | |||
| real(kind=dp), | intent(out) | :: | wr(*) | |||
| real(kind=dp), | intent(out) | :: | wi(*) | |||
| real(kind=dp), | intent(out) | :: | vs(ldvs,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldvs | |||
| real(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| logical(kind=lk), | intent(out) | :: | bwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
SGEES computes for an N-by-N real nonsymmetric matrix A, the eigenvalues, the real Schur form T, and, optionally, the matrix of Schur vectors Z. This gives the Schur factorization A = ZT(Z*T). Optionally, it also orders the eigenvalues on the diagonal of the real Schur form so that selected eigenvalues are at the top left. The leading columns of Z then form an orthonormal basis for the invariant subspace corresponding to the selected eigenvalues. A matrix is in real Schur form if it is upper quasi-triangular with 1-by-1 and 2-by-2 blocks. 2-by-2 blocks will be standardized in the form [ a b ] [ c a ] where bc < 0. The eigenvalues of such a block are a +- sqrt(bc).
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | jobvs | |||
| character, | intent(in) | :: | sort | |||
| procedure(stdlib_select_s) | :: | select | ||||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| integer(kind=ilp), | intent(out) | :: | sdim | |||
| real(kind=sp), | intent(out) | :: | wr(*) | |||
| real(kind=sp), | intent(out) | :: | wi(*) | |||
| real(kind=sp), | intent(out) | :: | vs(ldvs,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldvs | |||
| real(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| logical(kind=lk), | intent(out) | :: | bwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
ZGEES computes for an N-by-N complex nonsymmetric matrix A, the eigenvalues, the Schur form T, and, optionally, the matrix of Schur vectors Z. This gives the Schur factorization A = ZT(Z**H). Optionally, it also orders the eigenvalues on the diagonal of the Schur form so that selected eigenvalues are at the top left. The leading columns of Z then form an orthonormal basis for the invariant subspace corresponding to the selected eigenvalues. A complex matrix is in Schur form if it is upper triangular.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | jobvs | |||
| character, | intent(in) | :: | sort | |||
| procedure(stdlib_select_z) | :: | select | ||||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| integer(kind=ilp), | intent(out) | :: | sdim | |||
| complex(kind=dp), | intent(out) | :: | w(*) | |||
| complex(kind=dp), | intent(out) | :: | vs(ldvs,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldvs | |||
| complex(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| real(kind=dp), | intent(out) | :: | rwork(*) | |||
| logical(kind=lk), | intent(out) | :: | bwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
GEEV computes for an N-by-N complex nonsymmetric matrix A, the eigenvalues and, optionally, the left and/or right eigenvectors. The right eigenvector v(j) of A satisfies A * v(j) = lambda(j) * v(j) where lambda(j) is its eigenvalue. The left eigenvector u(j) of A satisfies u(j)H * A = lambda(j) * u(j)H where u(j)**H denotes the conjugate transpose of u(j). The computed eigenvectors are normalized to have Euclidean norm equal to 1 and largest component real.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | jobvl | |||
| character, | intent(in) | :: | jobvr | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=sp), | intent(out) | :: | w(*) | |||
| complex(kind=sp), | intent(out) | :: | vl(ldvl,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldvl | |||
| complex(kind=sp), | intent(out) | :: | vr(ldvr,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldvr | |||
| complex(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| real(kind=sp), | intent(out) | :: | rwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | jobvl | |||
| character, | intent(in) | :: | jobvr | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=dp), | intent(out) | :: | wr(*) | |||
| real(kind=dp), | intent(out) | :: | wi(*) | |||
| real(kind=dp), | intent(out) | :: | vl(ldvl,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldvl | |||
| real(kind=dp), | intent(out) | :: | vr(ldvr,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldvr | |||
| real(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | jobvl | |||
| character, | intent(in) | :: | jobvr | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=sp), | intent(out) | :: | wr(*) | |||
| real(kind=sp), | intent(out) | :: | wi(*) | |||
| real(kind=sp), | intent(out) | :: | vl(ldvl,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldvl | |||
| real(kind=sp), | intent(out) | :: | vr(ldvr,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldvr | |||
| real(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | jobvl | |||
| character, | intent(in) | :: | jobvr | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=dp), | intent(out) | :: | w(*) | |||
| complex(kind=dp), | intent(out) | :: | vl(ldvl,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldvl | |||
| complex(kind=dp), | intent(out) | :: | vr(ldvr,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldvr | |||
| complex(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| real(kind=dp), | intent(out) | :: | rwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
CGEEV computes for an N-by-N complex nonsymmetric matrix A, the eigenvalues and, optionally, the left and/or right eigenvectors. The right eigenvector v(j) of A satisfies A * v(j) = lambda(j) * v(j) where lambda(j) is its eigenvalue. The left eigenvector u(j) of A satisfies u(j)H * A = lambda(j) * u(j)H where u(j)**H denotes the conjugate transpose of u(j). The computed eigenvectors are normalized to have Euclidean norm equal to 1 and largest component real.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | jobvl | |||
| character, | intent(in) | :: | jobvr | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=sp), | intent(out) | :: | w(*) | |||
| complex(kind=sp), | intent(out) | :: | vl(ldvl,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldvl | |||
| complex(kind=sp), | intent(out) | :: | vr(ldvr,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldvr | |||
| complex(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| real(kind=sp), | intent(out) | :: | rwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
DGEEV computes for an N-by-N real nonsymmetric matrix A, the eigenvalues and, optionally, the left and/or right eigenvectors. The right eigenvector v(j) of A satisfies A * v(j) = lambda(j) * v(j) where lambda(j) is its eigenvalue. The left eigenvector u(j) of A satisfies u(j)H * A = lambda(j) * u(j)H where u(j)**H denotes the conjugate-transpose of u(j). The computed eigenvectors are normalized to have Euclidean norm equal to 1 and largest component real.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | jobvl | |||
| character, | intent(in) | :: | jobvr | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=dp), | intent(out) | :: | wr(*) | |||
| real(kind=dp), | intent(out) | :: | wi(*) | |||
| real(kind=dp), | intent(out) | :: | vl(ldvl,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldvl | |||
| real(kind=dp), | intent(out) | :: | vr(ldvr,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldvr | |||
| real(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
SGEEV computes for an N-by-N real nonsymmetric matrix A, the eigenvalues and, optionally, the left and/or right eigenvectors. The right eigenvector v(j) of A satisfies A * v(j) = lambda(j) * v(j) where lambda(j) is its eigenvalue. The left eigenvector u(j) of A satisfies u(j)H * A = lambda(j) * u(j)H where u(j)**H denotes the conjugate-transpose of u(j). The computed eigenvectors are normalized to have Euclidean norm equal to 1 and largest component real.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | jobvl | |||
| character, | intent(in) | :: | jobvr | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=sp), | intent(out) | :: | wr(*) | |||
| real(kind=sp), | intent(out) | :: | wi(*) | |||
| real(kind=sp), | intent(out) | :: | vl(ldvl,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldvl | |||
| real(kind=sp), | intent(out) | :: | vr(ldvr,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldvr | |||
| real(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
ZGEEV computes for an N-by-N complex nonsymmetric matrix A, the eigenvalues and, optionally, the left and/or right eigenvectors. The right eigenvector v(j) of A satisfies A * v(j) = lambda(j) * v(j) where lambda(j) is its eigenvalue. The left eigenvector u(j) of A satisfies u(j)H * A = lambda(j) * u(j)H where u(j)**H denotes the conjugate transpose of u(j). The computed eigenvectors are normalized to have Euclidean norm equal to 1 and largest component real.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | jobvl | |||
| character, | intent(in) | :: | jobvr | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=dp), | intent(out) | :: | w(*) | |||
| complex(kind=dp), | intent(out) | :: | vl(ldvl,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldvl | |||
| complex(kind=dp), | intent(out) | :: | vr(ldvr,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldvr | |||
| complex(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| real(kind=dp), | intent(out) | :: | rwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
GEHRD reduces a complex general matrix A to upper Hessenberg form H by an unitary similarity transformation: Q**H * A * Q = H .
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | ilo | |||
| integer(kind=ilp), | intent(in) | :: | ihi | |||
| complex(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=sp), | intent(out) | :: | tau(*) | |||
| complex(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | ilo | |||
| integer(kind=ilp), | intent(in) | :: | ihi | |||
| real(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=dp), | intent(out) | :: | tau(*) | |||
| real(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | ilo | |||
| integer(kind=ilp), | intent(in) | :: | ihi | |||
| real(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=sp), | intent(out) | :: | tau(*) | |||
| real(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | ilo | |||
| integer(kind=ilp), | intent(in) | :: | ihi | |||
| complex(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=dp), | intent(out) | :: | tau(*) | |||
| complex(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
CGEHRD reduces a complex general matrix A to upper Hessenberg form H by an unitary similarity transformation: Q**H * A * Q = H .
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | ilo | |||
| integer(kind=ilp), | intent(in) | :: | ihi | |||
| complex(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=sp), | intent(out) | :: | tau(*) | |||
| complex(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
DGEHRD reduces a real general matrix A to upper Hessenberg form H by an orthogonal similarity transformation: Q**T * A * Q = H .
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | ilo | |||
| integer(kind=ilp), | intent(in) | :: | ihi | |||
| real(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=dp), | intent(out) | :: | tau(*) | |||
| real(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
SGEHRD reduces a real general matrix A to upper Hessenberg form H by an orthogonal similarity transformation: Q**T * A * Q = H .
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | ilo | |||
| integer(kind=ilp), | intent(in) | :: | ihi | |||
| real(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=sp), | intent(out) | :: | tau(*) | |||
| real(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
ZGEHRD reduces a complex general matrix A to upper Hessenberg form H by an unitary similarity transformation: Q**H * A * Q = H .
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | ilo | |||
| integer(kind=ilp), | intent(in) | :: | ihi | |||
| complex(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=dp), | intent(out) | :: | tau(*) | |||
| complex(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
GEJSV computes the singular value decomposition (SVD) of a complex M-by-N matrix [A], where M >= N. The SVD of [A] is written as [A] = [U] * [SIGMA] * [V]^*, where [SIGMA] is an N-by-N (M-by-N) matrix which is zero except for its N diagonal elements, [U] is an M-by-N (or M-by-M) unitary matrix, and [V] is an N-by-N unitary matrix. The diagonal elements of [SIGMA] are the singular values of [A]. The columns of [U] and [V] are the left and the right singular vectors of [A], respectively. The matrices [U] and [V] are computed and stored in the arrays U and V, respectively. The diagonal of [SIGMA] is computed and stored in the array SVA.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | joba | |||
| character, | intent(in) | :: | jobu | |||
| character, | intent(in) | :: | jobv | |||
| character, | intent(in) | :: | jobr | |||
| character, | intent(in) | :: | jobt | |||
| character, | intent(in) | :: | jobp | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=sp), | intent(out) | :: | sva(n) | |||
| complex(kind=sp), | intent(out) | :: | u(ldu,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldu | |||
| complex(kind=sp), | intent(out) | :: | v(ldv,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldv | |||
| complex(kind=sp), | intent(out) | :: | cwork(lwork) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| real(kind=sp), | intent(out) | :: | rwork(lrwork) | |||
| integer(kind=ilp), | intent(in) | :: | lrwork | |||
| integer(kind=ilp), | intent(out) | :: | iwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | joba | |||
| character, | intent(in) | :: | jobu | |||
| character, | intent(in) | :: | jobv | |||
| character, | intent(in) | :: | jobr | |||
| character, | intent(in) | :: | jobt | |||
| character, | intent(in) | :: | jobp | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=dp), | intent(out) | :: | sva(n) | |||
| real(kind=dp), | intent(out) | :: | u(ldu,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldu | |||
| real(kind=dp), | intent(out) | :: | v(ldv,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldv | |||
| real(kind=dp), | intent(out) | :: | work(lwork) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | iwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | joba | |||
| character, | intent(in) | :: | jobu | |||
| character, | intent(in) | :: | jobv | |||
| character, | intent(in) | :: | jobr | |||
| character, | intent(in) | :: | jobt | |||
| character, | intent(in) | :: | jobp | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=sp), | intent(out) | :: | sva(n) | |||
| real(kind=sp), | intent(out) | :: | u(ldu,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldu | |||
| real(kind=sp), | intent(out) | :: | v(ldv,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldv | |||
| real(kind=sp), | intent(out) | :: | work(lwork) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | iwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | joba | |||
| character, | intent(in) | :: | jobu | |||
| character, | intent(in) | :: | jobv | |||
| character, | intent(in) | :: | jobr | |||
| character, | intent(in) | :: | jobt | |||
| character, | intent(in) | :: | jobp | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=dp), | intent(out) | :: | sva(n) | |||
| complex(kind=dp), | intent(out) | :: | u(ldu,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldu | |||
| complex(kind=dp), | intent(out) | :: | v(ldv,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldv | |||
| complex(kind=dp), | intent(out) | :: | cwork(lwork) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| real(kind=dp), | intent(out) | :: | rwork(lrwork) | |||
| integer(kind=ilp), | intent(in) | :: | lrwork | |||
| integer(kind=ilp), | intent(out) | :: | iwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
CGEJSV computes the singular value decomposition (SVD) of a complex M-by-N matrix [A], where M >= N. The SVD of [A] is written as [A] = [U] * [SIGMA] * [V]^*, where [SIGMA] is an N-by-N (M-by-N) matrix which is zero except for its N diagonal elements, [U] is an M-by-N (or M-by-M) unitary matrix, and [V] is an N-by-N unitary matrix. The diagonal elements of [SIGMA] are the singular values of [A]. The columns of [U] and [V] are the left and the right singular vectors of [A], respectively. The matrices [U] and [V] are computed and stored in the arrays U and V, respectively. The diagonal of [SIGMA] is computed and stored in the array SVA.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | joba | |||
| character, | intent(in) | :: | jobu | |||
| character, | intent(in) | :: | jobv | |||
| character, | intent(in) | :: | jobr | |||
| character, | intent(in) | :: | jobt | |||
| character, | intent(in) | :: | jobp | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=sp), | intent(out) | :: | sva(n) | |||
| complex(kind=sp), | intent(out) | :: | u(ldu,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldu | |||
| complex(kind=sp), | intent(out) | :: | v(ldv,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldv | |||
| complex(kind=sp), | intent(out) | :: | cwork(lwork) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| real(kind=sp), | intent(out) | :: | rwork(lrwork) | |||
| integer(kind=ilp), | intent(in) | :: | lrwork | |||
| integer(kind=ilp), | intent(out) | :: | iwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
DGEJSV computes the singular value decomposition (SVD) of a real M-by-N matrix [A], where M >= N. The SVD of [A] is written as [A] = [U] * [SIGMA] * [V]^t, where [SIGMA] is an N-by-N (M-by-N) matrix which is zero except for its N diagonal elements, [U] is an M-by-N (or M-by-M) orthonormal matrix, and [V] is an N-by-N orthogonal matrix. The diagonal elements of [SIGMA] are the singular values of [A]. The columns of [U] and [V] are the left and the right singular vectors of [A], respectively. The matrices [U] and [V] are computed and stored in the arrays U and V, respectively. The diagonal of [SIGMA] is computed and stored in the array SVA. DGEJSV can sometimes compute tiny singular values and their singular vectors much more accurately than other SVD routines, see below under Further Details.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | joba | |||
| character, | intent(in) | :: | jobu | |||
| character, | intent(in) | :: | jobv | |||
| character, | intent(in) | :: | jobr | |||
| character, | intent(in) | :: | jobt | |||
| character, | intent(in) | :: | jobp | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=dp), | intent(out) | :: | sva(n) | |||
| real(kind=dp), | intent(out) | :: | u(ldu,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldu | |||
| real(kind=dp), | intent(out) | :: | v(ldv,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldv | |||
| real(kind=dp), | intent(out) | :: | work(lwork) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | iwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
SGEJSV computes the singular value decomposition (SVD) of a real M-by-N matrix [A], where M >= N. The SVD of [A] is written as [A] = [U] * [SIGMA] * [V]^t, where [SIGMA] is an N-by-N (M-by-N) matrix which is zero except for its N diagonal elements, [U] is an M-by-N (or M-by-M) orthonormal matrix, and [V] is an N-by-N orthogonal matrix. The diagonal elements of [SIGMA] are the singular values of [A]. The columns of [U] and [V] are the left and the right singular vectors of [A], respectively. The matrices [U] and [V] are computed and stored in the arrays U and V, respectively. The diagonal of [SIGMA] is computed and stored in the array SVA. SGEJSV can sometimes compute tiny singular values and their singular vectors much more accurately than other SVD routines, see below under Further Details.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | joba | |||
| character, | intent(in) | :: | jobu | |||
| character, | intent(in) | :: | jobv | |||
| character, | intent(in) | :: | jobr | |||
| character, | intent(in) | :: | jobt | |||
| character, | intent(in) | :: | jobp | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=sp), | intent(out) | :: | sva(n) | |||
| real(kind=sp), | intent(out) | :: | u(ldu,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldu | |||
| real(kind=sp), | intent(out) | :: | v(ldv,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldv | |||
| real(kind=sp), | intent(out) | :: | work(lwork) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | iwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
ZGEJSV computes the singular value decomposition (SVD) of a complex M-by-N matrix [A], where M >= N. The SVD of [A] is written as [A] = [U] * [SIGMA] * [V]^*, where [SIGMA] is an N-by-N (M-by-N) matrix which is zero except for its N diagonal elements, [U] is an M-by-N (or M-by-M) unitary matrix, and [V] is an N-by-N unitary matrix. The diagonal elements of [SIGMA] are the singular values of [A]. The columns of [U] and [V] are the left and the right singular vectors of [A], respectively. The matrices [U] and [V] are computed and stored in the arrays U and V, respectively. The diagonal of [SIGMA] is computed and stored in the array SVA.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | joba | |||
| character, | intent(in) | :: | jobu | |||
| character, | intent(in) | :: | jobv | |||
| character, | intent(in) | :: | jobr | |||
| character, | intent(in) | :: | jobt | |||
| character, | intent(in) | :: | jobp | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=dp), | intent(out) | :: | sva(n) | |||
| complex(kind=dp), | intent(out) | :: | u(ldu,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldu | |||
| complex(kind=dp), | intent(out) | :: | v(ldv,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldv | |||
| complex(kind=dp), | intent(out) | :: | cwork(lwork) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| real(kind=dp), | intent(out) | :: | rwork(lrwork) | |||
| integer(kind=ilp), | intent(in) | :: | lrwork | |||
| integer(kind=ilp), | intent(out) | :: | iwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
GELQ computes an LQ factorization of a complex M-by-N matrix A: A = ( L 0 ) * Q where: Q is a N-by-N orthogonal matrix; L is a lower-triangular M-by-M matrix; 0 is a M-by-(N-M) zero matrix, if M < N.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=sp), | intent(out) | :: | t(*) | |||
| integer(kind=ilp), | intent(in) | :: | tsize | |||
| complex(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=dp), | intent(out) | :: | t(*) | |||
| integer(kind=ilp), | intent(in) | :: | tsize | |||
| real(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=sp), | intent(out) | :: | t(*) | |||
| integer(kind=ilp), | intent(in) | :: | tsize | |||
| real(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=dp), | intent(out) | :: | t(*) | |||
| integer(kind=ilp), | intent(in) | :: | tsize | |||
| complex(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
CGELQ computes an LQ factorization of a complex M-by-N matrix A: A = ( L 0 ) * Q where: Q is a N-by-N orthogonal matrix; L is a lower-triangular M-by-M matrix; 0 is a M-by-(N-M) zero matrix, if M < N.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=sp), | intent(out) | :: | t(*) | |||
| integer(kind=ilp), | intent(in) | :: | tsize | |||
| complex(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
DGELQ computes an LQ factorization of a real M-by-N matrix A: A = ( L 0 ) * Q where: Q is a N-by-N orthogonal matrix; L is a lower-triangular M-by-M matrix; 0 is a M-by-(N-M) zero matrix, if M < N.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=dp), | intent(out) | :: | t(*) | |||
| integer(kind=ilp), | intent(in) | :: | tsize | |||
| real(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
SGELQ computes an LQ factorization of a real M-by-N matrix A: A = ( L 0 ) * Q where: Q is a N-by-N orthogonal matrix; L is a lower-triangular M-by-M matrix; 0 is a M-by-(N-M) zero matrix, if M < N.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=sp), | intent(out) | :: | t(*) | |||
| integer(kind=ilp), | intent(in) | :: | tsize | |||
| real(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
ZGELQ computes an LQ factorization of a complex M-by-N matrix A: A = ( L 0 ) * Q where: Q is a N-by-N orthogonal matrix; L is a lower-triangular M-by-M matrix; 0 is a M-by-(N-M) zero matrix, if M < N.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=dp), | intent(out) | :: | t(*) | |||
| integer(kind=ilp), | intent(in) | :: | tsize | |||
| complex(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
GELQF computes an LQ factorization of a complex M-by-N matrix A: A = ( L 0 ) * Q where: Q is a N-by-N orthogonal matrix; L is a lower-triangular M-by-M matrix; 0 is a M-by-(N-M) zero matrix, if M < N.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=sp), | intent(out) | :: | tau(*) | |||
| complex(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=dp), | intent(out) | :: | tau(*) | |||
| real(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=sp), | intent(out) | :: | tau(*) | |||
| real(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=dp), | intent(out) | :: | tau(*) | |||
| complex(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
CGELQF computes an LQ factorization of a complex M-by-N matrix A: A = ( L 0 ) * Q where: Q is a N-by-N orthogonal matrix; L is a lower-triangular M-by-M matrix; 0 is a M-by-(N-M) zero matrix, if M < N.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=sp), | intent(out) | :: | tau(*) | |||
| complex(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
DGELQF computes an LQ factorization of a real M-by-N matrix A: A = ( L 0 ) * Q where: Q is a N-by-N orthogonal matrix; L is a lower-triangular M-by-M matrix; 0 is a M-by-(N-M) zero matrix, if M < N.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=dp), | intent(out) | :: | tau(*) | |||
| real(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
SGELQF computes an LQ factorization of a real M-by-N matrix A: A = ( L 0 ) * Q where: Q is a N-by-N orthogonal matrix; L is a lower-triangular M-by-M matrix; 0 is a M-by-(N-M) zero matrix, if M < N.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=sp), | intent(out) | :: | tau(*) | |||
| real(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
ZGELQF computes an LQ factorization of a complex M-by-N matrix A: A = ( L 0 ) * Q where: Q is a N-by-N orthogonal matrix; L is a lower-triangular M-by-M matrix; 0 is a M-by-(N-M) zero matrix, if M < N.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=dp), | intent(out) | :: | tau(*) | |||
| complex(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
GELQT computes a blocked LQ factorization of a complex M-by-N matrix A using the compact WY representation of Q.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | mb | |||
| complex(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=sp), | intent(out) | :: | t(ldt,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldt | |||
| complex(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | mb | |||
| real(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=dp), | intent(out) | :: | t(ldt,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldt | |||
| real(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | mb | |||
| real(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=sp), | intent(out) | :: | t(ldt,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldt | |||
| real(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | mb | |||
| complex(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=dp), | intent(out) | :: | t(ldt,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldt | |||
| complex(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
CGELQT computes a blocked LQ factorization of a complex M-by-N matrix A using the compact WY representation of Q.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | mb | |||
| complex(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=sp), | intent(out) | :: | t(ldt,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldt | |||
| complex(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
DGELQT computes a blocked LQ factorization of a real M-by-N matrix A using the compact WY representation of Q.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | mb | |||
| real(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=dp), | intent(out) | :: | t(ldt,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldt | |||
| real(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
DGELQT computes a blocked LQ factorization of a real M-by-N matrix A using the compact WY representation of Q.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | mb | |||
| real(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=sp), | intent(out) | :: | t(ldt,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldt | |||
| real(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
ZGELQT computes a blocked LQ factorization of a complex M-by-N matrix A using the compact WY representation of Q.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | mb | |||
| complex(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=dp), | intent(out) | :: | t(ldt,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldt | |||
| complex(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
GELQT3 recursively computes a LQ factorization of a complex M-by-N matrix A, using the compact WY representation of Q. Based on the algorithm of Elmroth and Gustavson, IBM J. Res. Develop. Vol 44 No. 4 July 2000.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=sp), | intent(out) | :: | t(ldt,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldt | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=dp), | intent(out) | :: | t(ldt,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldt | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=sp), | intent(out) | :: | t(ldt,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldt | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=dp), | intent(out) | :: | t(ldt,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldt | |||
| integer(kind=ilp), | intent(out) | :: | info |
CGELQT3 recursively computes a LQ factorization of a complex M-by-N matrix A, using the compact WY representation of Q. Based on the algorithm of Elmroth and Gustavson, IBM J. Res. Develop. Vol 44 No. 4 July 2000.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=sp), | intent(out) | :: | t(ldt,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldt | |||
| integer(kind=ilp), | intent(out) | :: | info |
DGELQT3 recursively computes a LQ factorization of a real M-by-N matrix A, using the compact WY representation of Q. Based on the algorithm of Elmroth and Gustavson, IBM J. Res. Develop. Vol 44 No. 4 July 2000.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=dp), | intent(out) | :: | t(ldt,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldt | |||
| integer(kind=ilp), | intent(out) | :: | info |
SGELQT3 recursively computes a LQ factorization of a real M-by-N matrix A, using the compact WY representation of Q. Based on the algorithm of Elmroth and Gustavson, IBM J. Res. Develop. Vol 44 No. 4 July 2000.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=sp), | intent(out) | :: | t(ldt,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldt | |||
| integer(kind=ilp), | intent(out) | :: | info |
ZGELQT3 recursively computes a LQ factorization of a complex M-by-N matrix A, using the compact WY representation of Q. Based on the algorithm of Elmroth and Gustavson, IBM J. Res. Develop. Vol 44 No. 4 July 2000.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=dp), | intent(out) | :: | t(ldt,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldt | |||
| integer(kind=ilp), | intent(out) | :: | info |
GELS solves overdetermined or underdetermined complex linear systems involving an M-by-N matrix A, or its conjugate-transpose, using a QR or LQ factorization of A. It is assumed that A has full rank. The following options are provided: 1. If TRANS = 'N' and m >= n: find the least squares solution of an overdetermined system, i.e., solve the least squares problem minimize || B - AX ||. 2. If TRANS = 'N' and m < n: find the minimum norm solution of an underdetermined system A * X = B. 3. If TRANS = 'C' and m >= n: find the minimum norm solution of an underdetermined system AH * X = B. 4. If TRANS = 'C' and m < n: find the least squares solution of an overdetermined system, i.e., solve the least squares problem minimize || B - A*H * X ||. Several right hand side vectors b and solution vectors x can be handled in a single call; they are stored as the columns of the M-by-NRHS right hand side matrix B and the N-by-NRHS solution matrix X.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | trans | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| complex(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=sp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| complex(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | trans | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| real(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=dp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| real(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | trans | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| real(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=sp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| real(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | trans | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| complex(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=dp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| complex(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
CGELS solves overdetermined or underdetermined complex linear systems involving an M-by-N matrix A, or its conjugate-transpose, using a QR or LQ factorization of A. It is assumed that A has full rank. The following options are provided: 1. If TRANS = 'N' and m >= n: find the least squares solution of an overdetermined system, i.e., solve the least squares problem minimize || B - AX ||. 2. If TRANS = 'N' and m < n: find the minimum norm solution of an underdetermined system A * X = B. 3. If TRANS = 'C' and m >= n: find the minimum norm solution of an underdetermined system AH * X = B. 4. If TRANS = 'C' and m < n: find the least squares solution of an overdetermined system, i.e., solve the least squares problem minimize || B - A*H * X ||. Several right hand side vectors b and solution vectors x can be handled in a single call; they are stored as the columns of the M-by-NRHS right hand side matrix B and the N-by-NRHS solution matrix X.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | trans | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| complex(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=sp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| complex(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
DGELS solves overdetermined or underdetermined real linear systems involving an M-by-N matrix A, or its transpose, using a QR or LQ factorization of A. It is assumed that A has full rank. The following options are provided: 1. If TRANS = 'N' and m >= n: find the least squares solution of an overdetermined system, i.e., solve the least squares problem minimize || B - AX ||. 2. If TRANS = 'N' and m < n: find the minimum norm solution of an underdetermined system A * X = B. 3. If TRANS = 'T' and m >= n: find the minimum norm solution of an underdetermined system AT * X = B. 4. If TRANS = 'T' and m < n: find the least squares solution of an overdetermined system, i.e., solve the least squares problem minimize || B - A*T * X ||. Several right hand side vectors b and solution vectors x can be handled in a single call; they are stored as the columns of the M-by-NRHS right hand side matrix B and the N-by-NRHS solution matrix X.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | trans | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| real(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=dp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| real(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
SGELS solves overdetermined or underdetermined real linear systems involving an M-by-N matrix A, or its transpose, using a QR or LQ factorization of A. It is assumed that A has full rank. The following options are provided: 1. If TRANS = 'N' and m >= n: find the least squares solution of an overdetermined system, i.e., solve the least squares problem minimize || B - AX ||. 2. If TRANS = 'N' and m < n: find the minimum norm solution of an underdetermined system A * X = B. 3. If TRANS = 'T' and m >= n: find the minimum norm solution of an underdetermined system AT * X = B. 4. If TRANS = 'T' and m < n: find the least squares solution of an overdetermined system, i.e., solve the least squares problem minimize || B - A*T * X ||. Several right hand side vectors b and solution vectors x can be handled in a single call; they are stored as the columns of the M-by-NRHS right hand side matrix B and the N-by-NRHS solution matrix X.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | trans | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| real(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=sp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| real(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
ZGELS solves overdetermined or underdetermined complex linear systems involving an M-by-N matrix A, or its conjugate-transpose, using a QR or LQ factorization of A. It is assumed that A has full rank. The following options are provided: 1. If TRANS = 'N' and m >= n: find the least squares solution of an overdetermined system, i.e., solve the least squares problem minimize || B - AX ||. 2. If TRANS = 'N' and m < n: find the minimum norm solution of an underdetermined system A * X = B. 3. If TRANS = 'C' and m >= n: find the minimum norm solution of an underdetermined system AH * X = B. 4. If TRANS = 'C' and m < n: find the least squares solution of an overdetermined system, i.e., solve the least squares problem minimize || B - A*H * X ||. Several right hand side vectors b and solution vectors x can be handled in a single call; they are stored as the columns of the M-by-NRHS right hand side matrix B and the N-by-NRHS solution matrix X.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | trans | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| complex(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=dp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| complex(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
GELSD computes the minimum-norm solution to a real linear least squares problem: minimize 2-norm(| b - A*x |) using the singular value decomposition (SVD) of A. A is an M-by-N matrix which may be rank-deficient. Several right hand side vectors b and solution vectors x can be handled in a single call; they are stored as the columns of the M-by-NRHS right hand side matrix B and the N-by-NRHS solution matrix X. The problem is solved in three steps: (1) Reduce the coefficient matrix A to bidiagonal form with Householder transformations, reducing the original problem into a "bidiagonal least squares problem" (BLS) (2) Solve the BLS using a divide and conquer approach. (3) Apply back all the Householder transformations to solve the original least squares problem. The effective rank of A is determined by treating as zero those singular values which are less than RCOND times the largest singular value. The divide and conquer algorithm makes very mild assumptions about floating point arithmetic. It will work on machines with a guard digit in add/subtract, or on those binary machines without guard digits which subtract like the Cray X-MP, Cray Y-MP, Cray C-90, or Cray-2. It could conceivably fail on hexadecimal or decimal machines without guard digits, but we know of none.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| complex(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=sp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| real(kind=sp), | intent(out) | :: | s(*) | |||
| real(kind=sp), | intent(in) | :: | rcond | |||
| integer(kind=ilp), | intent(out) | :: | rank | |||
| complex(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| real(kind=sp), | intent(out) | :: | rwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | iwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| real(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=dp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| real(kind=dp), | intent(out) | :: | s(*) | |||
| real(kind=dp), | intent(in) | :: | rcond | |||
| integer(kind=ilp), | intent(out) | :: | rank | |||
| real(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | iwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| real(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=sp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| real(kind=sp), | intent(out) | :: | s(*) | |||
| real(kind=sp), | intent(in) | :: | rcond | |||
| integer(kind=ilp), | intent(out) | :: | rank | |||
| real(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | iwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| complex(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=dp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| real(kind=dp), | intent(out) | :: | s(*) | |||
| real(kind=dp), | intent(in) | :: | rcond | |||
| integer(kind=ilp), | intent(out) | :: | rank | |||
| complex(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| real(kind=dp), | intent(out) | :: | rwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | iwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
CGELSD computes the minimum-norm solution to a real linear least squares problem: minimize 2-norm(| b - A*x |) using the singular value decomposition (SVD) of A. A is an M-by-N matrix which may be rank-deficient. Several right hand side vectors b and solution vectors x can be handled in a single call; they are stored as the columns of the M-by-NRHS right hand side matrix B and the N-by-NRHS solution matrix X. The problem is solved in three steps: (1) Reduce the coefficient matrix A to bidiagonal form with Householder transformations, reducing the original problem into a "bidiagonal least squares problem" (BLS) (2) Solve the BLS using a divide and conquer approach. (3) Apply back all the Householder transformations to solve the original least squares problem. The effective rank of A is determined by treating as zero those singular values which are less than RCOND times the largest singular value. The divide and conquer algorithm makes very mild assumptions about floating point arithmetic. It will work on machines with a guard digit in add/subtract, or on those binary machines without guard digits which subtract like the Cray X-MP, Cray Y-MP, Cray C-90, or Cray-2. It could conceivably fail on hexadecimal or decimal machines without guard digits, but we know of none.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| complex(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=sp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| real(kind=sp), | intent(out) | :: | s(*) | |||
| real(kind=sp), | intent(in) | :: | rcond | |||
| integer(kind=ilp), | intent(out) | :: | rank | |||
| complex(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| real(kind=sp), | intent(out) | :: | rwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | iwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
DGELSD computes the minimum-norm solution to a real linear least squares problem: minimize 2-norm(| b - A*x |) using the singular value decomposition (SVD) of A. A is an M-by-N matrix which may be rank-deficient. Several right hand side vectors b and solution vectors x can be handled in a single call; they are stored as the columns of the M-by-NRHS right hand side matrix B and the N-by-NRHS solution matrix X. The problem is solved in three steps: (1) Reduce the coefficient matrix A to bidiagonal form with Householder transformations, reducing the original problem into a "bidiagonal least squares problem" (BLS) (2) Solve the BLS using a divide and conquer approach. (3) Apply back all the Householder transformations to solve the original least squares problem. The effective rank of A is determined by treating as zero those singular values which are less than RCOND times the largest singular value. The divide and conquer algorithm makes very mild assumptions about floating point arithmetic. It will work on machines with a guard digit in add/subtract, or on those binary machines without guard digits which subtract like the Cray X-MP, Cray Y-MP, Cray C-90, or Cray-2. It could conceivably fail on hexadecimal or decimal machines without guard digits, but we know of none.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| real(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=dp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| real(kind=dp), | intent(out) | :: | s(*) | |||
| real(kind=dp), | intent(in) | :: | rcond | |||
| integer(kind=ilp), | intent(out) | :: | rank | |||
| real(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | iwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
SGELSD computes the minimum-norm solution to a real linear least squares problem: minimize 2-norm(| b - A*x |) using the singular value decomposition (SVD) of A. A is an M-by-N matrix which may be rank-deficient. Several right hand side vectors b and solution vectors x can be handled in a single call; they are stored as the columns of the M-by-NRHS right hand side matrix B and the N-by-NRHS solution matrix X. The problem is solved in three steps: (1) Reduce the coefficient matrix A to bidiagonal form with Householder transformations, reducing the original problem into a "bidiagonal least squares problem" (BLS) (2) Solve the BLS using a divide and conquer approach. (3) Apply back all the Householder transformations to solve the original least squares problem. The effective rank of A is determined by treating as zero those singular values which are less than RCOND times the largest singular value. The divide and conquer algorithm makes very mild assumptions about floating point arithmetic. It will work on machines with a guard digit in add/subtract, or on those binary machines without guard digits which subtract like the Cray X-MP, Cray Y-MP, Cray C-90, or Cray-2. It could conceivably fail on hexadecimal or decimal machines without guard digits, but we know of none.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| real(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=sp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| real(kind=sp), | intent(out) | :: | s(*) | |||
| real(kind=sp), | intent(in) | :: | rcond | |||
| integer(kind=ilp), | intent(out) | :: | rank | |||
| real(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | iwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
ZGELSD computes the minimum-norm solution to a real linear least squares problem: minimize 2-norm(| b - A*x |) using the singular value decomposition (SVD) of A. A is an M-by-N matrix which may be rank-deficient. Several right hand side vectors b and solution vectors x can be handled in a single call; they are stored as the columns of the M-by-NRHS right hand side matrix B and the N-by-NRHS solution matrix X. The problem is solved in three steps: (1) Reduce the coefficient matrix A to bidiagonal form with Householder transformations, reducing the original problem into a "bidiagonal least squares problem" (BLS) (2) Solve the BLS using a divide and conquer approach. (3) Apply back all the Householder transformations to solve the original least squares problem. The effective rank of A is determined by treating as zero those singular values which are less than RCOND times the largest singular value. The divide and conquer algorithm makes very mild assumptions about floating point arithmetic. It will work on machines with a guard digit in add/subtract, or on those binary machines without guard digits which subtract like the Cray X-MP, Cray Y-MP, Cray C-90, or Cray-2. It could conceivably fail on hexadecimal or decimal machines without guard digits, but we know of none.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| complex(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=dp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| real(kind=dp), | intent(out) | :: | s(*) | |||
| real(kind=dp), | intent(in) | :: | rcond | |||
| integer(kind=ilp), | intent(out) | :: | rank | |||
| complex(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| real(kind=dp), | intent(out) | :: | rwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | iwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
GELSS computes the minimum norm solution to a complex linear least squares problem: Minimize 2-norm(| b - A*x |). using the singular value decomposition (SVD) of A. A is an M-by-N matrix which may be rank-deficient. Several right hand side vectors b and solution vectors x can be handled in a single call; they are stored as the columns of the M-by-NRHS right hand side matrix B and the N-by-NRHS solution matrix X. The effective rank of A is determined by treating as zero those singular values which are less than RCOND times the largest singular value.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| complex(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=sp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| real(kind=sp), | intent(out) | :: | s(*) | |||
| real(kind=sp), | intent(in) | :: | rcond | |||
| integer(kind=ilp), | intent(out) | :: | rank | |||
| complex(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| real(kind=sp), | intent(out) | :: | rwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| real(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=dp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| real(kind=dp), | intent(out) | :: | s(*) | |||
| real(kind=dp), | intent(in) | :: | rcond | |||
| integer(kind=ilp), | intent(out) | :: | rank | |||
| real(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| real(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=sp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| real(kind=sp), | intent(out) | :: | s(*) | |||
| real(kind=sp), | intent(in) | :: | rcond | |||
| integer(kind=ilp), | intent(out) | :: | rank | |||
| real(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| complex(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=dp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| real(kind=dp), | intent(out) | :: | s(*) | |||
| real(kind=dp), | intent(in) | :: | rcond | |||
| integer(kind=ilp), | intent(out) | :: | rank | |||
| complex(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| real(kind=dp), | intent(out) | :: | rwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
CGELSS computes the minimum norm solution to a complex linear least squares problem: Minimize 2-norm(| b - A*x |). using the singular value decomposition (SVD) of A. A is an M-by-N matrix which may be rank-deficient. Several right hand side vectors b and solution vectors x can be handled in a single call; they are stored as the columns of the M-by-NRHS right hand side matrix B and the N-by-NRHS solution matrix X. The effective rank of A is determined by treating as zero those singular values which are less than RCOND times the largest singular value.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| complex(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=sp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| real(kind=sp), | intent(out) | :: | s(*) | |||
| real(kind=sp), | intent(in) | :: | rcond | |||
| integer(kind=ilp), | intent(out) | :: | rank | |||
| complex(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| real(kind=sp), | intent(out) | :: | rwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
DGELSS computes the minimum norm solution to a real linear least squares problem: Minimize 2-norm(| b - A*x |). using the singular value decomposition (SVD) of A. A is an M-by-N matrix which may be rank-deficient. Several right hand side vectors b and solution vectors x can be handled in a single call; they are stored as the columns of the M-by-NRHS right hand side matrix B and the N-by-NRHS solution matrix X. The effective rank of A is determined by treating as zero those singular values which are less than RCOND times the largest singular value.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| real(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=dp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| real(kind=dp), | intent(out) | :: | s(*) | |||
| real(kind=dp), | intent(in) | :: | rcond | |||
| integer(kind=ilp), | intent(out) | :: | rank | |||
| real(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
SGELSS computes the minimum norm solution to a real linear least squares problem: Minimize 2-norm(| b - A*x |). using the singular value decomposition (SVD) of A. A is an M-by-N matrix which may be rank-deficient. Several right hand side vectors b and solution vectors x can be handled in a single call; they are stored as the columns of the M-by-NRHS right hand side matrix B and the N-by-NRHS solution matrix X. The effective rank of A is determined by treating as zero those singular values which are less than RCOND times the largest singular value.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| real(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=sp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| real(kind=sp), | intent(out) | :: | s(*) | |||
| real(kind=sp), | intent(in) | :: | rcond | |||
| integer(kind=ilp), | intent(out) | :: | rank | |||
| real(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
ZGELSS computes the minimum norm solution to a complex linear least squares problem: Minimize 2-norm(| b - A*x |). using the singular value decomposition (SVD) of A. A is an M-by-N matrix which may be rank-deficient. Several right hand side vectors b and solution vectors x can be handled in a single call; they are stored as the columns of the M-by-NRHS right hand side matrix B and the N-by-NRHS solution matrix X. The effective rank of A is determined by treating as zero those singular values which are less than RCOND times the largest singular value.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| complex(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=dp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| real(kind=dp), | intent(out) | :: | s(*) | |||
| real(kind=dp), | intent(in) | :: | rcond | |||
| integer(kind=ilp), | intent(out) | :: | rank | |||
| complex(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| real(kind=dp), | intent(out) | :: | rwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
GELSY computes the minimum-norm solution to a complex linear least squares problem: minimize || A * X - B || using a complete orthogonal factorization of A. A is an M-by-N matrix which may be rank-deficient. Several right hand side vectors b and solution vectors x can be handled in a single call; they are stored as the columns of the M-by-NRHS right hand side matrix B and the N-by-NRHS solution matrix X. The routine first computes a QR factorization with column pivoting: A * P = Q * [ R11 R12 ] [ 0 R22 ] with R11 defined as the largest leading submatrix whose estimated condition number is less than 1/RCOND. The order of R11, RANK, is the effective rank of A. Then, R22 is considered to be negligible, and R12 is annihilated by unitary transformations from the right, arriving at the complete orthogonal factorization: A * P = Q * [ T11 0 ] * Z [ 0 0 ] The minimum-norm solution is then X = P * ZH [ inv(T11)*Q1H*B ] [ 0 ] where Q1 consists of the first RANK columns of Q. This routine is basically identical to the original xGELSX except three differences: o The permutation of matrix B (the right hand side) is faster and more simple. o The call to the subroutine xGEQPF has been substituted by the the call to the subroutine xGEQP3. This subroutine is a Blas-3 version of the QR factorization with column pivoting. o Matrix B (the right hand side) is updated with Blas-3.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| complex(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=sp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| integer(kind=ilp), | intent(inout) | :: | jpvt(*) | |||
| real(kind=sp), | intent(in) | :: | rcond | |||
| integer(kind=ilp), | intent(out) | :: | rank | |||
| complex(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| real(kind=sp), | intent(out) | :: | rwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| real(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=dp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| integer(kind=ilp), | intent(inout) | :: | jpvt(*) | |||
| real(kind=dp), | intent(in) | :: | rcond | |||
| integer(kind=ilp), | intent(out) | :: | rank | |||
| real(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| real(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=sp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| integer(kind=ilp), | intent(inout) | :: | jpvt(*) | |||
| real(kind=sp), | intent(in) | :: | rcond | |||
| integer(kind=ilp), | intent(out) | :: | rank | |||
| real(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| complex(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=dp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| integer(kind=ilp), | intent(inout) | :: | jpvt(*) | |||
| real(kind=dp), | intent(in) | :: | rcond | |||
| integer(kind=ilp), | intent(out) | :: | rank | |||
| complex(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| real(kind=dp), | intent(out) | :: | rwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
CGELSY computes the minimum-norm solution to a complex linear least squares problem: minimize || A * X - B || using a complete orthogonal factorization of A. A is an M-by-N matrix which may be rank-deficient. Several right hand side vectors b and solution vectors x can be handled in a single call; they are stored as the columns of the M-by-NRHS right hand side matrix B and the N-by-NRHS solution matrix X. The routine first computes a QR factorization with column pivoting: A * P = Q * [ R11 R12 ] [ 0 R22 ] with R11 defined as the largest leading submatrix whose estimated condition number is less than 1/RCOND. The order of R11, RANK, is the effective rank of A. Then, R22 is considered to be negligible, and R12 is annihilated by unitary transformations from the right, arriving at the complete orthogonal factorization: A * P = Q * [ T11 0 ] * Z [ 0 0 ] The minimum-norm solution is then X = P * ZH [ inv(T11)*Q1H*B ] [ 0 ] where Q1 consists of the first RANK columns of Q. This routine is basically identical to the original xGELSX except three differences: o The permutation of matrix B (the right hand side) is faster and more simple. o The call to the subroutine xGEQPF has been substituted by the the call to the subroutine xGEQP3. This subroutine is a Blas-3 version of the QR factorization with column pivoting. o Matrix B (the right hand side) is updated with Blas-3.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| complex(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=sp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| integer(kind=ilp), | intent(inout) | :: | jpvt(*) | |||
| real(kind=sp), | intent(in) | :: | rcond | |||
| integer(kind=ilp), | intent(out) | :: | rank | |||
| complex(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| real(kind=sp), | intent(out) | :: | rwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
DGELSY computes the minimum-norm solution to a real linear least squares problem: minimize || A * X - B || using a complete orthogonal factorization of A. A is an M-by-N matrix which may be rank-deficient. Several right hand side vectors b and solution vectors x can be handled in a single call; they are stored as the columns of the M-by-NRHS right hand side matrix B and the N-by-NRHS solution matrix X. The routine first computes a QR factorization with column pivoting: A * P = Q * [ R11 R12 ] [ 0 R22 ] with R11 defined as the largest leading submatrix whose estimated condition number is less than 1/RCOND. The order of R11, RANK, is the effective rank of A. Then, R22 is considered to be negligible, and R12 is annihilated by orthogonal transformations from the right, arriving at the complete orthogonal factorization: A * P = Q * [ T11 0 ] * Z [ 0 0 ] The minimum-norm solution is then X = P * ZT [ inv(T11)*Q1T*B ] [ 0 ] where Q1 consists of the first RANK columns of Q. This routine is basically identical to the original xGELSX except three differences: o The call to the subroutine xGEQPF has been substituted by the the call to the subroutine xGEQP3. This subroutine is a Blas-3 version of the QR factorization with column pivoting. o Matrix B (the right hand side) is updated with Blas-3. o The permutation of matrix B (the right hand side) is faster and more simple.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| real(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=dp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| integer(kind=ilp), | intent(inout) | :: | jpvt(*) | |||
| real(kind=dp), | intent(in) | :: | rcond | |||
| integer(kind=ilp), | intent(out) | :: | rank | |||
| real(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
SGELSY computes the minimum-norm solution to a real linear least squares problem: minimize || A * X - B || using a complete orthogonal factorization of A. A is an M-by-N matrix which may be rank-deficient. Several right hand side vectors b and solution vectors x can be handled in a single call; they are stored as the columns of the M-by-NRHS right hand side matrix B and the N-by-NRHS solution matrix X. The routine first computes a QR factorization with column pivoting: A * P = Q * [ R11 R12 ] [ 0 R22 ] with R11 defined as the largest leading submatrix whose estimated condition number is less than 1/RCOND. The order of R11, RANK, is the effective rank of A. Then, R22 is considered to be negligible, and R12 is annihilated by orthogonal transformations from the right, arriving at the complete orthogonal factorization: A * P = Q * [ T11 0 ] * Z [ 0 0 ] The minimum-norm solution is then X = P * ZT [ inv(T11)*Q1T*B ] [ 0 ] where Q1 consists of the first RANK columns of Q. This routine is basically identical to the original xGELSX except three differences: o The call to the subroutine xGEQPF has been substituted by the the call to the subroutine xGEQP3. This subroutine is a Blas-3 version of the QR factorization with column pivoting. o Matrix B (the right hand side) is updated with Blas-3. o The permutation of matrix B (the right hand side) is faster and more simple.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| real(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=sp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| integer(kind=ilp), | intent(inout) | :: | jpvt(*) | |||
| real(kind=sp), | intent(in) | :: | rcond | |||
| integer(kind=ilp), | intent(out) | :: | rank | |||
| real(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
ZGELSY computes the minimum-norm solution to a complex linear least squares problem: minimize || A * X - B || using a complete orthogonal factorization of A. A is an M-by-N matrix which may be rank-deficient. Several right hand side vectors b and solution vectors x can be handled in a single call; they are stored as the columns of the M-by-NRHS right hand side matrix B and the N-by-NRHS solution matrix X. The routine first computes a QR factorization with column pivoting: A * P = Q * [ R11 R12 ] [ 0 R22 ] with R11 defined as the largest leading submatrix whose estimated condition number is less than 1/RCOND. The order of R11, RANK, is the effective rank of A. Then, R22 is considered to be negligible, and R12 is annihilated by unitary transformations from the right, arriving at the complete orthogonal factorization: A * P = Q * [ T11 0 ] * Z [ 0 0 ] The minimum-norm solution is then X = P * ZH [ inv(T11)*Q1H*B ] [ 0 ] where Q1 consists of the first RANK columns of Q. This routine is basically identical to the original xGELSX except three differences: o The permutation of matrix B (the right hand side) is faster and more simple. o The call to the subroutine xGEQPF has been substituted by the the call to the subroutine xGEQP3. This subroutine is a Blas-3 version of the QR factorization with column pivoting. o Matrix B (the right hand side) is updated with Blas-3.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| complex(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=dp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| integer(kind=ilp), | intent(inout) | :: | jpvt(*) | |||
| real(kind=dp), | intent(in) | :: | rcond | |||
| integer(kind=ilp), | intent(out) | :: | rank | |||
| complex(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| real(kind=dp), | intent(out) | :: | rwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
GEMLQ overwrites the general real M-by-N matrix C with SIDE = 'L' SIDE = 'R' TRANS = 'N': Q * C C * Q TRANS = 'C': QH * C C * QH where Q is a complex unitary matrix defined as the product of blocked elementary reflectors computed by short wide LQ factorization (CGELQ)
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | side | |||
| character, | intent(in) | :: | trans | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | k | |||
| complex(kind=sp), | intent(in) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=sp), | intent(in) | :: | t(*) | |||
| integer(kind=ilp), | intent(in) | :: | tsize | |||
| complex(kind=sp), | intent(inout) | :: | c(ldc,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldc | |||
| complex(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | side | |||
| character, | intent(in) | :: | trans | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | k | |||
| real(kind=dp), | intent(in) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=dp), | intent(in) | :: | t(*) | |||
| integer(kind=ilp), | intent(in) | :: | tsize | |||
| real(kind=dp), | intent(inout) | :: | c(ldc,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldc | |||
| real(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | side | |||
| character, | intent(in) | :: | trans | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | k | |||
| real(kind=sp), | intent(in) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=sp), | intent(in) | :: | t(*) | |||
| integer(kind=ilp), | intent(in) | :: | tsize | |||
| real(kind=sp), | intent(inout) | :: | c(ldc,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldc | |||
| real(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | side | |||
| character, | intent(in) | :: | trans | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | k | |||
| complex(kind=dp), | intent(in) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=dp), | intent(in) | :: | t(*) | |||
| integer(kind=ilp), | intent(in) | :: | tsize | |||
| complex(kind=dp), | intent(inout) | :: | c(ldc,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldc | |||
| complex(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
CGEMLQ overwrites the general real M-by-N matrix C with SIDE = 'L' SIDE = 'R' TRANS = 'N': Q * C C * Q TRANS = 'C': QH * C C * QH where Q is a complex unitary matrix defined as the product of blocked elementary reflectors computed by short wide LQ factorization (CGELQ)
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | side | |||
| character, | intent(in) | :: | trans | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | k | |||
| complex(kind=sp), | intent(in) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=sp), | intent(in) | :: | t(*) | |||
| integer(kind=ilp), | intent(in) | :: | tsize | |||
| complex(kind=sp), | intent(inout) | :: | c(ldc,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldc | |||
| complex(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
DGEMLQ overwrites the general real M-by-N matrix C with SIDE = 'L' SIDE = 'R' TRANS = 'N': Q * C C * Q TRANS = 'T': QT * C C * QT where Q is a real orthogonal matrix defined as the product of blocked elementary reflectors computed by short wide LQ factorization (DGELQ)
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | side | |||
| character, | intent(in) | :: | trans | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | k | |||
| real(kind=dp), | intent(in) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=dp), | intent(in) | :: | t(*) | |||
| integer(kind=ilp), | intent(in) | :: | tsize | |||
| real(kind=dp), | intent(inout) | :: | c(ldc,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldc | |||
| real(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
SGEMLQ overwrites the general real M-by-N matrix C with SIDE = 'L' SIDE = 'R' TRANS = 'N': Q * C C * Q TRANS = 'T': QT * C C * QT where Q is a real orthogonal matrix defined as the product of blocked elementary reflectors computed by short wide LQ factorization (SGELQ)
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | side | |||
| character, | intent(in) | :: | trans | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | k | |||
| real(kind=sp), | intent(in) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=sp), | intent(in) | :: | t(*) | |||
| integer(kind=ilp), | intent(in) | :: | tsize | |||
| real(kind=sp), | intent(inout) | :: | c(ldc,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldc | |||
| real(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
ZGEMLQ overwrites the general real M-by-N matrix C with SIDE = 'L' SIDE = 'R' TRANS = 'N': Q * C C * Q TRANS = 'C': QH * C C * QH where Q is a complex unitary matrix defined as the product of blocked elementary reflectors computed by short wide LQ factorization (ZGELQ)
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | side | |||
| character, | intent(in) | :: | trans | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | k | |||
| complex(kind=dp), | intent(in) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=dp), | intent(in) | :: | t(*) | |||
| integer(kind=ilp), | intent(in) | :: | tsize | |||
| complex(kind=dp), | intent(inout) | :: | c(ldc,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldc | |||
| complex(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
GEMLQT overwrites the general complex M-by-N matrix C with SIDE = 'L' SIDE = 'R' TRANS = 'N': Q C C Q TRANS = 'C': QH C C QH where Q is a complex unitary matrix defined as the product of K elementary reflectors: Q = H(1) H(2) . . . H(K) = I - V T V**H generated using the compact WY representation as returned by CGELQT. Q is of order M if SIDE = 'L' and of order N if SIDE = 'R'.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | side | |||
| character, | intent(in) | :: | trans | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | k | |||
| integer(kind=ilp), | intent(in) | :: | mb | |||
| complex(kind=sp), | intent(in) | :: | v(ldv,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldv | |||
| complex(kind=sp), | intent(in) | :: | t(ldt,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldt | |||
| complex(kind=sp), | intent(inout) | :: | c(ldc,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldc | |||
| complex(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | side | |||
| character, | intent(in) | :: | trans | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | k | |||
| integer(kind=ilp), | intent(in) | :: | mb | |||
| real(kind=dp), | intent(in) | :: | v(ldv,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldv | |||
| real(kind=dp), | intent(in) | :: | t(ldt,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldt | |||
| real(kind=dp), | intent(inout) | :: | c(ldc,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldc | |||
| real(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | side | |||
| character, | intent(in) | :: | trans | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | k | |||
| integer(kind=ilp), | intent(in) | :: | mb | |||
| real(kind=sp), | intent(in) | :: | v(ldv,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldv | |||
| real(kind=sp), | intent(in) | :: | t(ldt,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldt | |||
| real(kind=sp), | intent(inout) | :: | c(ldc,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldc | |||
| real(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | side | |||
| character, | intent(in) | :: | trans | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | k | |||
| integer(kind=ilp), | intent(in) | :: | mb | |||
| complex(kind=dp), | intent(in) | :: | v(ldv,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldv | |||
| complex(kind=dp), | intent(in) | :: | t(ldt,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldt | |||
| complex(kind=dp), | intent(inout) | :: | c(ldc,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldc | |||
| complex(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
CGEMLQT overwrites the general complex M-by-N matrix C with SIDE = 'L' SIDE = 'R' TRANS = 'N': Q C C Q TRANS = 'C': QH C C QH where Q is a complex unitary matrix defined as the product of K elementary reflectors: Q = H(1) H(2) . . . H(K) = I - V T V**H generated using the compact WY representation as returned by CGELQT. Q is of order M if SIDE = 'L' and of order N if SIDE = 'R'.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | side | |||
| character, | intent(in) | :: | trans | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | k | |||
| integer(kind=ilp), | intent(in) | :: | mb | |||
| complex(kind=sp), | intent(in) | :: | v(ldv,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldv | |||
| complex(kind=sp), | intent(in) | :: | t(ldt,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldt | |||
| complex(kind=sp), | intent(inout) | :: | c(ldc,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldc | |||
| complex(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
DGEMLQT overwrites the general real M-by-N matrix C with SIDE = 'L' SIDE = 'R' TRANS = 'N': Q C C Q TRANS = 'T': QT C C QT where Q is a real orthogonal matrix defined as the product of K elementary reflectors: Q = H(1) H(2) . . . H(K) = I - V T V**T generated using the compact WY representation as returned by DGELQT. Q is of order M if SIDE = 'L' and of order N if SIDE = 'R'.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | side | |||
| character, | intent(in) | :: | trans | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | k | |||
| integer(kind=ilp), | intent(in) | :: | mb | |||
| real(kind=dp), | intent(in) | :: | v(ldv,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldv | |||
| real(kind=dp), | intent(in) | :: | t(ldt,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldt | |||
| real(kind=dp), | intent(inout) | :: | c(ldc,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldc | |||
| real(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
DGEMLQT overwrites the general real M-by-N matrix C with SIDE = 'L' SIDE = 'R' TRANS = 'N': Q C C Q TRANS = 'T': QT C C QT where Q is a real orthogonal matrix defined as the product of K elementary reflectors: Q = H(1) H(2) . . . H(K) = I - V T V**T generated using the compact WY representation as returned by SGELQT. Q is of order M if SIDE = 'L' and of order N if SIDE = 'R'.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | side | |||
| character, | intent(in) | :: | trans | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | k | |||
| integer(kind=ilp), | intent(in) | :: | mb | |||
| real(kind=sp), | intent(in) | :: | v(ldv,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldv | |||
| real(kind=sp), | intent(in) | :: | t(ldt,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldt | |||
| real(kind=sp), | intent(inout) | :: | c(ldc,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldc | |||
| real(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
ZGEMLQT overwrites the general complex M-by-N matrix C with SIDE = 'L' SIDE = 'R' TRANS = 'N': Q C C Q TRANS = 'C': QH C C QH where Q is a complex unitary matrix defined as the product of K elementary reflectors: Q = H(1) H(2) . . . H(K) = I - V T V**H generated using the compact WY representation as returned by ZGELQT. Q is of order M if SIDE = 'L' and of order N if SIDE = 'R'.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | side | |||
| character, | intent(in) | :: | trans | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | k | |||
| integer(kind=ilp), | intent(in) | :: | mb | |||
| complex(kind=dp), | intent(in) | :: | v(ldv,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldv | |||
| complex(kind=dp), | intent(in) | :: | t(ldt,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldt | |||
| complex(kind=dp), | intent(inout) | :: | c(ldc,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldc | |||
| complex(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
GEMQR overwrites the general real M-by-N matrix C with SIDE = 'L' SIDE = 'R' TRANS = 'N': Q * C C * Q TRANS = 'T': QH * C C * QH where Q is a complex unitary matrix defined as the product of blocked elementary reflectors computed by tall skinny QR factorization (CGEQR)
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | side | |||
| character, | intent(in) | :: | trans | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | k | |||
| complex(kind=sp), | intent(in) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=sp), | intent(in) | :: | t(*) | |||
| integer(kind=ilp), | intent(in) | :: | tsize | |||
| complex(kind=sp), | intent(inout) | :: | c(ldc,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldc | |||
| complex(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | side | |||
| character, | intent(in) | :: | trans | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | k | |||
| real(kind=dp), | intent(in) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=dp), | intent(in) | :: | t(*) | |||
| integer(kind=ilp), | intent(in) | :: | tsize | |||
| real(kind=dp), | intent(inout) | :: | c(ldc,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldc | |||
| real(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | side | |||
| character, | intent(in) | :: | trans | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | k | |||
| real(kind=sp), | intent(in) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=sp), | intent(in) | :: | t(*) | |||
| integer(kind=ilp), | intent(in) | :: | tsize | |||
| real(kind=sp), | intent(inout) | :: | c(ldc,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldc | |||
| real(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | side | |||
| character, | intent(in) | :: | trans | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | k | |||
| complex(kind=dp), | intent(in) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=dp), | intent(in) | :: | t(*) | |||
| integer(kind=ilp), | intent(in) | :: | tsize | |||
| complex(kind=dp), | intent(inout) | :: | c(ldc,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldc | |||
| complex(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
CGEMQR overwrites the general real M-by-N matrix C with SIDE = 'L' SIDE = 'R' TRANS = 'N': Q * C C * Q TRANS = 'T': QH * C C * QH where Q is a complex unitary matrix defined as the product of blocked elementary reflectors computed by tall skinny QR factorization (CGEQR)
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | side | |||
| character, | intent(in) | :: | trans | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | k | |||
| complex(kind=sp), | intent(in) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=sp), | intent(in) | :: | t(*) | |||
| integer(kind=ilp), | intent(in) | :: | tsize | |||
| complex(kind=sp), | intent(inout) | :: | c(ldc,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldc | |||
| complex(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
DGEMQR overwrites the general real M-by-N matrix C with SIDE = 'L' SIDE = 'R' TRANS = 'N': Q * C C * Q TRANS = 'T': QT * C C * QT where Q is a real orthogonal matrix defined as the product of blocked elementary reflectors computed by tall skinny QR factorization (DGEQR)
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | side | |||
| character, | intent(in) | :: | trans | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | k | |||
| real(kind=dp), | intent(in) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=dp), | intent(in) | :: | t(*) | |||
| integer(kind=ilp), | intent(in) | :: | tsize | |||
| real(kind=dp), | intent(inout) | :: | c(ldc,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldc | |||
| real(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
SGEMQR overwrites the general real M-by-N matrix C with SIDE = 'L' SIDE = 'R' TRANS = 'N': Q * C C * Q TRANS = 'T': QT * C C * QT where Q is a real orthogonal matrix defined as the product of blocked elementary reflectors computed by tall skinny QR factorization (SGEQR)
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | side | |||
| character, | intent(in) | :: | trans | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | k | |||
| real(kind=sp), | intent(in) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=sp), | intent(in) | :: | t(*) | |||
| integer(kind=ilp), | intent(in) | :: | tsize | |||
| real(kind=sp), | intent(inout) | :: | c(ldc,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldc | |||
| real(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
ZGEMQR overwrites the general real M-by-N matrix C with SIDE = 'L' SIDE = 'R' TRANS = 'N': Q * C C * Q TRANS = 'T': QH * C C * QH where Q is a complex unitary matrix defined as the product of blocked elementary reflectors computed by tall skinny QR factorization (ZGEQR)
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | side | |||
| character, | intent(in) | :: | trans | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | k | |||
| complex(kind=dp), | intent(in) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=dp), | intent(in) | :: | t(*) | |||
| integer(kind=ilp), | intent(in) | :: | tsize | |||
| complex(kind=dp), | intent(inout) | :: | c(ldc,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldc | |||
| complex(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
GEMQRT overwrites the general complex M-by-N matrix C with SIDE = 'L' SIDE = 'R' TRANS = 'N': Q C C Q TRANS = 'C': QH C C QH where Q is a complex orthogonal matrix defined as the product of K elementary reflectors: Q = H(1) H(2) . . . H(K) = I - V T V**H generated using the compact WY representation as returned by CGEQRT. Q is of order M if SIDE = 'L' and of order N if SIDE = 'R'.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | side | |||
| character, | intent(in) | :: | trans | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | k | |||
| integer(kind=ilp), | intent(in) | :: | nb | |||
| complex(kind=sp), | intent(in) | :: | v(ldv,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldv | |||
| complex(kind=sp), | intent(in) | :: | t(ldt,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldt | |||
| complex(kind=sp), | intent(inout) | :: | c(ldc,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldc | |||
| complex(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | side | |||
| character, | intent(in) | :: | trans | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | k | |||
| integer(kind=ilp), | intent(in) | :: | nb | |||
| real(kind=dp), | intent(in) | :: | v(ldv,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldv | |||
| real(kind=dp), | intent(in) | :: | t(ldt,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldt | |||
| real(kind=dp), | intent(inout) | :: | c(ldc,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldc | |||
| real(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | side | |||
| character, | intent(in) | :: | trans | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | k | |||
| integer(kind=ilp), | intent(in) | :: | nb | |||
| real(kind=sp), | intent(in) | :: | v(ldv,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldv | |||
| real(kind=sp), | intent(in) | :: | t(ldt,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldt | |||
| real(kind=sp), | intent(inout) | :: | c(ldc,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldc | |||
| real(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | side | |||
| character, | intent(in) | :: | trans | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | k | |||
| integer(kind=ilp), | intent(in) | :: | nb | |||
| complex(kind=dp), | intent(in) | :: | v(ldv,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldv | |||
| complex(kind=dp), | intent(in) | :: | t(ldt,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldt | |||
| complex(kind=dp), | intent(inout) | :: | c(ldc,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldc | |||
| complex(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
CGEMQRT overwrites the general complex M-by-N matrix C with SIDE = 'L' SIDE = 'R' TRANS = 'N': Q C C Q TRANS = 'C': QH C C QH where Q is a complex orthogonal matrix defined as the product of K elementary reflectors: Q = H(1) H(2) . . . H(K) = I - V T V**H generated using the compact WY representation as returned by CGEQRT. Q is of order M if SIDE = 'L' and of order N if SIDE = 'R'.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | side | |||
| character, | intent(in) | :: | trans | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | k | |||
| integer(kind=ilp), | intent(in) | :: | nb | |||
| complex(kind=sp), | intent(in) | :: | v(ldv,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldv | |||
| complex(kind=sp), | intent(in) | :: | t(ldt,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldt | |||
| complex(kind=sp), | intent(inout) | :: | c(ldc,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldc | |||
| complex(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
DGEMQRT overwrites the general real M-by-N matrix C with SIDE = 'L' SIDE = 'R' TRANS = 'N': Q C C Q TRANS = 'T': QT C C QT where Q is a real orthogonal matrix defined as the product of K elementary reflectors: Q = H(1) H(2) . . . H(K) = I - V T V**T generated using the compact WY representation as returned by DGEQRT. Q is of order M if SIDE = 'L' and of order N if SIDE = 'R'.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | side | |||
| character, | intent(in) | :: | trans | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | k | |||
| integer(kind=ilp), | intent(in) | :: | nb | |||
| real(kind=dp), | intent(in) | :: | v(ldv,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldv | |||
| real(kind=dp), | intent(in) | :: | t(ldt,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldt | |||
| real(kind=dp), | intent(inout) | :: | c(ldc,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldc | |||
| real(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
SGEMQRT overwrites the general real M-by-N matrix C with SIDE = 'L' SIDE = 'R' TRANS = 'N': Q C C Q TRANS = 'T': QT C C QT where Q is a real orthogonal matrix defined as the product of K elementary reflectors: Q = H(1) H(2) . . . H(K) = I - V T V**T generated using the compact WY representation as returned by SGEQRT. Q is of order M if SIDE = 'L' and of order N if SIDE = 'R'.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | side | |||
| character, | intent(in) | :: | trans | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | k | |||
| integer(kind=ilp), | intent(in) | :: | nb | |||
| real(kind=sp), | intent(in) | :: | v(ldv,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldv | |||
| real(kind=sp), | intent(in) | :: | t(ldt,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldt | |||
| real(kind=sp), | intent(inout) | :: | c(ldc,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldc | |||
| real(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
ZGEMQRT overwrites the general complex M-by-N matrix C with SIDE = 'L' SIDE = 'R' TRANS = 'N': Q C C Q TRANS = 'C': QH C C QH where Q is a complex orthogonal matrix defined as the product of K elementary reflectors: Q = H(1) H(2) . . . H(K) = I - V T V**H generated using the compact WY representation as returned by ZGEQRT. Q is of order M if SIDE = 'L' and of order N if SIDE = 'R'.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | side | |||
| character, | intent(in) | :: | trans | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | k | |||
| integer(kind=ilp), | intent(in) | :: | nb | |||
| complex(kind=dp), | intent(in) | :: | v(ldv,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldv | |||
| complex(kind=dp), | intent(in) | :: | t(ldt,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldt | |||
| complex(kind=dp), | intent(inout) | :: | c(ldc,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldc | |||
| complex(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
GEQLF computes a QL factorization of a complex M-by-N matrix A: A = Q * L.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=sp), | intent(out) | :: | tau(*) | |||
| complex(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=dp), | intent(out) | :: | tau(*) | |||
| real(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=sp), | intent(out) | :: | tau(*) | |||
| real(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=dp), | intent(out) | :: | tau(*) | |||
| complex(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
CGEQLF computes a QL factorization of a complex M-by-N matrix A: A = Q * L.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=sp), | intent(out) | :: | tau(*) | |||
| complex(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
DGEQLF computes a QL factorization of a real M-by-N matrix A: A = Q * L.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=dp), | intent(out) | :: | tau(*) | |||
| real(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
SGEQLF computes a QL factorization of a real M-by-N matrix A: A = Q * L.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=sp), | intent(out) | :: | tau(*) | |||
| real(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
ZGEQLF computes a QL factorization of a complex M-by-N matrix A: A = Q * L.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=dp), | intent(out) | :: | tau(*) | |||
| complex(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
GEQR computes a QR factorization of a complex M-by-N matrix A: A = Q * ( R ), ( 0 ) where: Q is a M-by-M orthogonal matrix; R is an upper-triangular N-by-N matrix; 0 is a (M-N)-by-N zero matrix, if M > N.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=sp), | intent(out) | :: | t(*) | |||
| integer(kind=ilp), | intent(in) | :: | tsize | |||
| complex(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=dp), | intent(out) | :: | t(*) | |||
| integer(kind=ilp), | intent(in) | :: | tsize | |||
| real(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=sp), | intent(out) | :: | t(*) | |||
| integer(kind=ilp), | intent(in) | :: | tsize | |||
| real(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=dp), | intent(out) | :: | t(*) | |||
| integer(kind=ilp), | intent(in) | :: | tsize | |||
| complex(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
CGEQR computes a QR factorization of a complex M-by-N matrix A: A = Q * ( R ), ( 0 ) where: Q is a M-by-M orthogonal matrix; R is an upper-triangular N-by-N matrix; 0 is a (M-N)-by-N zero matrix, if M > N.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=sp), | intent(out) | :: | t(*) | |||
| integer(kind=ilp), | intent(in) | :: | tsize | |||
| complex(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
DGEQR computes a QR factorization of a real M-by-N matrix A: A = Q * ( R ), ( 0 ) where: Q is a M-by-M orthogonal matrix; R is an upper-triangular N-by-N matrix; 0 is a (M-N)-by-N zero matrix, if M > N.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=dp), | intent(out) | :: | t(*) | |||
| integer(kind=ilp), | intent(in) | :: | tsize | |||
| real(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
SGEQR computes a QR factorization of a real M-by-N matrix A: A = Q * ( R ), ( 0 ) where: Q is a M-by-M orthogonal matrix; R is an upper-triangular N-by-N matrix; 0 is a (M-N)-by-N zero matrix, if M > N.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=sp), | intent(out) | :: | t(*) | |||
| integer(kind=ilp), | intent(in) | :: | tsize | |||
| real(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
ZGEQR computes a QR factorization of a complex M-by-N matrix A: A = Q * ( R ), ( 0 ) where: Q is a M-by-M orthogonal matrix; R is an upper-triangular N-by-N matrix; 0 is a (M-N)-by-N zero matrix, if M > N.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=dp), | intent(out) | :: | t(*) | |||
| integer(kind=ilp), | intent(in) | :: | tsize | |||
| complex(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
GEQR2P computes a QR factorization of a complex m-by-n matrix A: A = Q * ( R ), ( 0 ) where: Q is a m-by-m orthogonal matrix; R is an upper-triangular n-by-n matrix with nonnegative diagonal entries; 0 is a (m-n)-by-n zero matrix, if m > n.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=sp), | intent(out) | :: | tau(*) | |||
| complex(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=dp), | intent(out) | :: | tau(*) | |||
| real(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=sp), | intent(out) | :: | tau(*) | |||
| real(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=dp), | intent(out) | :: | tau(*) | |||
| complex(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
CGEQR2P computes a QR factorization of a complex m-by-n matrix A: A = Q * ( R ), ( 0 ) where: Q is a m-by-m orthogonal matrix; R is an upper-triangular n-by-n matrix with nonnegative diagonal entries; 0 is a (m-n)-by-n zero matrix, if m > n.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=sp), | intent(out) | :: | tau(*) | |||
| complex(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
DGEQR2P computes a QR factorization of a real m-by-n matrix A: A = Q * ( R ), ( 0 ) where: Q is a m-by-m orthogonal matrix; R is an upper-triangular n-by-n matrix with nonnegative diagonal entries; 0 is a (m-n)-by-n zero matrix, if m > n.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=dp), | intent(out) | :: | tau(*) | |||
| real(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
SGEQR2P computes a QR factorization of a real m-by-n matrix A: A = Q * ( R ), ( 0 ) where: Q is a m-by-m orthogonal matrix; R is an upper-triangular n-by-n matrix with nonnegative diagonal entries; 0 is a (m-n)-by-n zero matrix, if m > n.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=sp), | intent(out) | :: | tau(*) | |||
| real(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
ZGEQR2P computes a QR factorization of a complex m-by-n matrix A: A = Q * ( R ), ( 0 ) where: Q is a m-by-m orthogonal matrix; R is an upper-triangular n-by-n matrix with nonnegative diagonal entries; 0 is a (m-n)-by-n zero matrix, if m > n.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=dp), | intent(out) | :: | tau(*) | |||
| complex(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
GEQRF computes a QR factorization of a complex M-by-N matrix A: A = Q * ( R ), ( 0 ) where: Q is a M-by-M orthogonal matrix; R is an upper-triangular N-by-N matrix; 0 is a (M-N)-by-N zero matrix, if M > N.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=sp), | intent(out) | :: | tau(*) | |||
| complex(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=dp), | intent(out) | :: | tau(*) | |||
| real(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=sp), | intent(out) | :: | tau(*) | |||
| real(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=dp), | intent(out) | :: | tau(*) | |||
| complex(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
CGEQRF computes a QR factorization of a complex M-by-N matrix A: A = Q * ( R ), ( 0 ) where: Q is a M-by-M orthogonal matrix; R is an upper-triangular N-by-N matrix; 0 is a (M-N)-by-N zero matrix, if M > N.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=sp), | intent(out) | :: | tau(*) | |||
| complex(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
DGEQRF computes a QR factorization of a real M-by-N matrix A: A = Q * ( R ), ( 0 ) where: Q is a M-by-M orthogonal matrix; R is an upper-triangular N-by-N matrix; 0 is a (M-N)-by-N zero matrix, if M > N.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=dp), | intent(out) | :: | tau(*) | |||
| real(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
SGEQRF computes a QR factorization of a real M-by-N matrix A: A = Q * ( R ), ( 0 ) where: Q is a M-by-M orthogonal matrix; R is an upper-triangular N-by-N matrix; 0 is a (M-N)-by-N zero matrix, if M > N.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=sp), | intent(out) | :: | tau(*) | |||
| real(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
ZGEQRF computes a QR factorization of a complex M-by-N matrix A: A = Q * ( R ), ( 0 ) where: Q is a M-by-M orthogonal matrix; R is an upper-triangular N-by-N matrix; 0 is a (M-N)-by-N zero matrix, if M > N.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=dp), | intent(out) | :: | tau(*) | |||
| complex(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
CGEQR2P computes a QR factorization of a complex M-by-N matrix A: A = Q * ( R ), ( 0 ) where: Q is a M-by-M orthogonal matrix; R is an upper-triangular N-by-N matrix with nonnegative diagonal entries; 0 is a (M-N)-by-N zero matrix, if M > N.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=sp), | intent(out) | :: | tau(*) | |||
| complex(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=dp), | intent(out) | :: | tau(*) | |||
| real(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=sp), | intent(out) | :: | tau(*) | |||
| real(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=dp), | intent(out) | :: | tau(*) | |||
| complex(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
CGEQR2P computes a QR factorization of a complex M-by-N matrix A: A = Q * ( R ), ( 0 ) where: Q is a M-by-M orthogonal matrix; R is an upper-triangular N-by-N matrix with nonnegative diagonal entries; 0 is a (M-N)-by-N zero matrix, if M > N.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=sp), | intent(out) | :: | tau(*) | |||
| complex(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
DGEQR2P computes a QR factorization of a real M-by-N matrix A: A = Q * ( R ), ( 0 ) where: Q is a M-by-M orthogonal matrix; R is an upper-triangular N-by-N matrix with nonnegative diagonal entries; 0 is a (M-N)-by-N zero matrix, if M > N.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=dp), | intent(out) | :: | tau(*) | |||
| real(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
SGEQR2P computes a QR factorization of a real M-by-N matrix A: A = Q * ( R ), ( 0 ) where: Q is a M-by-M orthogonal matrix; R is an upper-triangular N-by-N matrix with nonnegative diagonal entries; 0 is a (M-N)-by-N zero matrix, if M > N.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=sp), | intent(out) | :: | tau(*) | |||
| real(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
ZGEQR2P computes a QR factorization of a complex M-by-N matrix A: A = Q * ( R ), ( 0 ) where: Q is a M-by-M orthogonal matrix; R is an upper-triangular N-by-N matrix with nonnegative diagonal entries; 0 is a (M-N)-by-N zero matrix, if M > N.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=dp), | intent(out) | :: | tau(*) | |||
| complex(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
GEQRT computes a blocked QR factorization of a complex M-by-N matrix A using the compact WY representation of Q.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nb | |||
| complex(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=sp), | intent(out) | :: | t(ldt,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldt | |||
| complex(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nb | |||
| real(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=dp), | intent(out) | :: | t(ldt,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldt | |||
| real(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nb | |||
| real(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=sp), | intent(out) | :: | t(ldt,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldt | |||
| real(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nb | |||
| complex(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=dp), | intent(out) | :: | t(ldt,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldt | |||
| complex(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
CGEQRT computes a blocked QR factorization of a complex M-by-N matrix A using the compact WY representation of Q.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nb | |||
| complex(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=sp), | intent(out) | :: | t(ldt,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldt | |||
| complex(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
DGEQRT computes a blocked QR factorization of a real M-by-N matrix A using the compact WY representation of Q.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nb | |||
| real(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=dp), | intent(out) | :: | t(ldt,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldt | |||
| real(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
SGEQRT computes a blocked QR factorization of a real M-by-N matrix A using the compact WY representation of Q.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nb | |||
| real(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=sp), | intent(out) | :: | t(ldt,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldt | |||
| real(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
ZGEQRT computes a blocked QR factorization of a complex M-by-N matrix A using the compact WY representation of Q.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nb | |||
| complex(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=dp), | intent(out) | :: | t(ldt,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldt | |||
| complex(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
GEQRT2 computes a QR factorization of a complex M-by-N matrix A, using the compact WY representation of Q.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=sp), | intent(out) | :: | t(ldt,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldt | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=dp), | intent(out) | :: | t(ldt,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldt | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=sp), | intent(out) | :: | t(ldt,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldt | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=dp), | intent(out) | :: | t(ldt,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldt | |||
| integer(kind=ilp), | intent(out) | :: | info |
CGEQRT2 computes a QR factorization of a complex M-by-N matrix A, using the compact WY representation of Q.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=sp), | intent(out) | :: | t(ldt,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldt | |||
| integer(kind=ilp), | intent(out) | :: | info |
DGEQRT2 computes a QR factorization of a real M-by-N matrix A, using the compact WY representation of Q.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=dp), | intent(out) | :: | t(ldt,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldt | |||
| integer(kind=ilp), | intent(out) | :: | info |
SGEQRT2 computes a QR factorization of a real M-by-N matrix A, using the compact WY representation of Q.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=sp), | intent(out) | :: | t(ldt,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldt | |||
| integer(kind=ilp), | intent(out) | :: | info |
ZGEQRT2 computes a QR factorization of a complex M-by-N matrix A, using the compact WY representation of Q.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=dp), | intent(out) | :: | t(ldt,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldt | |||
| integer(kind=ilp), | intent(out) | :: | info |
GEQRT3 recursively computes a QR factorization of a complex M-by-N matrix A, using the compact WY representation of Q. Based on the algorithm of Elmroth and Gustavson, IBM J. Res. Develop. Vol 44 No. 4 July 2000.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=sp), | intent(out) | :: | t(ldt,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldt | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=dp), | intent(out) | :: | t(ldt,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldt | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=sp), | intent(out) | :: | t(ldt,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldt | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=dp), | intent(out) | :: | t(ldt,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldt | |||
| integer(kind=ilp), | intent(out) | :: | info |
CGEQRT3 recursively computes a QR factorization of a complex M-by-N matrix A, using the compact WY representation of Q. Based on the algorithm of Elmroth and Gustavson, IBM J. Res. Develop. Vol 44 No. 4 July 2000.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=sp), | intent(out) | :: | t(ldt,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldt | |||
| integer(kind=ilp), | intent(out) | :: | info |
DGEQRT3 recursively computes a QR factorization of a real M-by-N matrix A, using the compact WY representation of Q. Based on the algorithm of Elmroth and Gustavson, IBM J. Res. Develop. Vol 44 No. 4 July 2000.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=dp), | intent(out) | :: | t(ldt,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldt | |||
| integer(kind=ilp), | intent(out) | :: | info |
SGEQRT3 recursively computes a QR factorization of a real M-by-N matrix A, using the compact WY representation of Q. Based on the algorithm of Elmroth and Gustavson, IBM J. Res. Develop. Vol 44 No. 4 July 2000.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=sp), | intent(out) | :: | t(ldt,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldt | |||
| integer(kind=ilp), | intent(out) | :: | info |
ZGEQRT3 recursively computes a QR factorization of a complex M-by-N matrix A, using the compact WY representation of Q. Based on the algorithm of Elmroth and Gustavson, IBM J. Res. Develop. Vol 44 No. 4 July 2000.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=dp), | intent(out) | :: | t(ldt,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldt | |||
| integer(kind=ilp), | intent(out) | :: | info |
GERFS improves the computed solution to a system of linear equations and provides error bounds and backward error estimates for the solution.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | trans | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| complex(kind=sp), | intent(in) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=sp), | intent(in) | :: | af(ldaf,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldaf | |||
| integer(kind=ilp), | intent(in) | :: | ipiv(*) | |||
| complex(kind=sp), | intent(in) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| complex(kind=sp), | intent(inout) | :: | x(ldx,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldx | |||
| real(kind=sp), | intent(out) | :: | ferr(*) | |||
| real(kind=sp), | intent(out) | :: | berr(*) | |||
| complex(kind=sp), | intent(out) | :: | work(*) | |||
| real(kind=sp), | intent(out) | :: | rwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | trans | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| real(kind=dp), | intent(in) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=dp), | intent(in) | :: | af(ldaf,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldaf | |||
| integer(kind=ilp), | intent(in) | :: | ipiv(*) | |||
| real(kind=dp), | intent(in) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| real(kind=dp), | intent(inout) | :: | x(ldx,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldx | |||
| real(kind=dp), | intent(out) | :: | ferr(*) | |||
| real(kind=dp), | intent(out) | :: | berr(*) | |||
| real(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | iwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | trans | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| real(kind=sp), | intent(in) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=sp), | intent(in) | :: | af(ldaf,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldaf | |||
| integer(kind=ilp), | intent(in) | :: | ipiv(*) | |||
| real(kind=sp), | intent(in) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| real(kind=sp), | intent(inout) | :: | x(ldx,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldx | |||
| real(kind=sp), | intent(out) | :: | ferr(*) | |||
| real(kind=sp), | intent(out) | :: | berr(*) | |||
| real(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | iwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | trans | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| complex(kind=dp), | intent(in) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=dp), | intent(in) | :: | af(ldaf,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldaf | |||
| integer(kind=ilp), | intent(in) | :: | ipiv(*) | |||
| complex(kind=dp), | intent(in) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| complex(kind=dp), | intent(inout) | :: | x(ldx,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldx | |||
| real(kind=dp), | intent(out) | :: | ferr(*) | |||
| real(kind=dp), | intent(out) | :: | berr(*) | |||
| complex(kind=dp), | intent(out) | :: | work(*) | |||
| real(kind=dp), | intent(out) | :: | rwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
CGERFS improves the computed solution to a system of linear equations and provides error bounds and backward error estimates for the solution.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | trans | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| complex(kind=sp), | intent(in) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=sp), | intent(in) | :: | af(ldaf,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldaf | |||
| integer(kind=ilp), | intent(in) | :: | ipiv(*) | |||
| complex(kind=sp), | intent(in) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| complex(kind=sp), | intent(inout) | :: | x(ldx,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldx | |||
| real(kind=sp), | intent(out) | :: | ferr(*) | |||
| real(kind=sp), | intent(out) | :: | berr(*) | |||
| complex(kind=sp), | intent(out) | :: | work(*) | |||
| real(kind=sp), | intent(out) | :: | rwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
DGERFS improves the computed solution to a system of linear equations and provides error bounds and backward error estimates for the solution.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | trans | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| real(kind=dp), | intent(in) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=dp), | intent(in) | :: | af(ldaf,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldaf | |||
| integer(kind=ilp), | intent(in) | :: | ipiv(*) | |||
| real(kind=dp), | intent(in) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| real(kind=dp), | intent(inout) | :: | x(ldx,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldx | |||
| real(kind=dp), | intent(out) | :: | ferr(*) | |||
| real(kind=dp), | intent(out) | :: | berr(*) | |||
| real(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | iwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
SGERFS improves the computed solution to a system of linear equations and provides error bounds and backward error estimates for the solution.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | trans | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| real(kind=sp), | intent(in) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=sp), | intent(in) | :: | af(ldaf,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldaf | |||
| integer(kind=ilp), | intent(in) | :: | ipiv(*) | |||
| real(kind=sp), | intent(in) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| real(kind=sp), | intent(inout) | :: | x(ldx,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldx | |||
| real(kind=sp), | intent(out) | :: | ferr(*) | |||
| real(kind=sp), | intent(out) | :: | berr(*) | |||
| real(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | iwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
ZGERFS improves the computed solution to a system of linear equations and provides error bounds and backward error estimates for the solution.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | trans | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| complex(kind=dp), | intent(in) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=dp), | intent(in) | :: | af(ldaf,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldaf | |||
| integer(kind=ilp), | intent(in) | :: | ipiv(*) | |||
| complex(kind=dp), | intent(in) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| complex(kind=dp), | intent(inout) | :: | x(ldx,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldx | |||
| real(kind=dp), | intent(out) | :: | ferr(*) | |||
| real(kind=dp), | intent(out) | :: | berr(*) | |||
| complex(kind=dp), | intent(out) | :: | work(*) | |||
| real(kind=dp), | intent(out) | :: | rwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
GERQF computes an RQ factorization of a complex M-by-N matrix A: A = R * Q.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=sp), | intent(out) | :: | tau(*) | |||
| complex(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=dp), | intent(out) | :: | tau(*) | |||
| real(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=sp), | intent(out) | :: | tau(*) | |||
| real(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=dp), | intent(out) | :: | tau(*) | |||
| complex(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
CGERQF computes an RQ factorization of a complex M-by-N matrix A: A = R * Q.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=sp), | intent(out) | :: | tau(*) | |||
| complex(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
DGERQF computes an RQ factorization of a real M-by-N matrix A: A = R * Q.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=dp), | intent(out) | :: | tau(*) | |||
| real(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
SGERQF computes an RQ factorization of a real M-by-N matrix A: A = R * Q.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=sp), | intent(out) | :: | tau(*) | |||
| real(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
ZGERQF computes an RQ factorization of a complex M-by-N matrix A: A = R * Q.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=dp), | intent(out) | :: | tau(*) | |||
| complex(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
GESDD computes the singular value decomposition (SVD) of a complex M-by-N matrix A, optionally computing the left and/or right singular vectors, by using divide-and-conquer method. The SVD is written A = U * SIGMA * conjugate-transpose(V) where SIGMA is an M-by-N matrix which is zero except for its min(m,n) diagonal elements, U is an M-by-M unitary matrix, and V is an N-by-N unitary matrix. The diagonal elements of SIGMA are the singular values of A; they are real and non-negative, and are returned in descending order. The first min(m,n) columns of U and V are the left and right singular vectors of A. Note that the routine returns VT = V**H, not V. The divide and conquer algorithm makes very mild assumptions about floating point arithmetic. It will work on machines with a guard digit in add/subtract, or on those binary machines without guard digits which subtract like the Cray X-MP, Cray Y-MP, Cray C-90, or Cray-2. It could conceivably fail on hexadecimal or decimal machines without guard digits, but we know of none.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | jobz | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=sp), | intent(out) | :: | s(*) | |||
| complex(kind=sp), | intent(out) | :: | u(ldu,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldu | |||
| complex(kind=sp), | intent(out) | :: | vt(ldvt,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldvt | |||
| complex(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| real(kind=sp), | intent(out) | :: | rwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | iwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | jobz | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=dp), | intent(out) | :: | s(*) | |||
| real(kind=dp), | intent(out) | :: | u(ldu,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldu | |||
| real(kind=dp), | intent(out) | :: | vt(ldvt,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldvt | |||
| real(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | iwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | jobz | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=sp), | intent(out) | :: | s(*) | |||
| real(kind=sp), | intent(out) | :: | u(ldu,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldu | |||
| real(kind=sp), | intent(out) | :: | vt(ldvt,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldvt | |||
| real(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | iwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | jobz | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=dp), | intent(out) | :: | s(*) | |||
| complex(kind=dp), | intent(out) | :: | u(ldu,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldu | |||
| complex(kind=dp), | intent(out) | :: | vt(ldvt,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldvt | |||
| complex(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| real(kind=dp), | intent(out) | :: | rwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | iwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
CGESDD computes the singular value decomposition (SVD) of a complex M-by-N matrix A, optionally computing the left and/or right singular vectors, by using divide-and-conquer method. The SVD is written A = U * SIGMA * conjugate-transpose(V) where SIGMA is an M-by-N matrix which is zero except for its min(m,n) diagonal elements, U is an M-by-M unitary matrix, and V is an N-by-N unitary matrix. The diagonal elements of SIGMA are the singular values of A; they are real and non-negative, and are returned in descending order. The first min(m,n) columns of U and V are the left and right singular vectors of A. Note that the routine returns VT = V**H, not V. The divide and conquer algorithm makes very mild assumptions about floating point arithmetic. It will work on machines with a guard digit in add/subtract, or on those binary machines without guard digits which subtract like the Cray X-MP, Cray Y-MP, Cray C-90, or Cray-2. It could conceivably fail on hexadecimal or decimal machines without guard digits, but we know of none.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | jobz | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=sp), | intent(out) | :: | s(*) | |||
| complex(kind=sp), | intent(out) | :: | u(ldu,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldu | |||
| complex(kind=sp), | intent(out) | :: | vt(ldvt,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldvt | |||
| complex(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| real(kind=sp), | intent(out) | :: | rwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | iwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
DGESDD computes the singular value decomposition (SVD) of a real M-by-N matrix A, optionally computing the left and right singular vectors. If singular vectors are desired, it uses a divide-and-conquer algorithm. The SVD is written A = U * SIGMA * transpose(V) where SIGMA is an M-by-N matrix which is zero except for its min(m,n) diagonal elements, U is an M-by-M orthogonal matrix, and V is an N-by-N orthogonal matrix. The diagonal elements of SIGMA are the singular values of A; they are real and non-negative, and are returned in descending order. The first min(m,n) columns of U and V are the left and right singular vectors of A. Note that the routine returns VT = V**T, not V. The divide and conquer algorithm makes very mild assumptions about floating point arithmetic. It will work on machines with a guard digit in add/subtract, or on those binary machines without guard digits which subtract like the Cray X-MP, Cray Y-MP, Cray C-90, or Cray-2. It could conceivably fail on hexadecimal or decimal machines without guard digits, but we know of none.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | jobz | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=dp), | intent(out) | :: | s(*) | |||
| real(kind=dp), | intent(out) | :: | u(ldu,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldu | |||
| real(kind=dp), | intent(out) | :: | vt(ldvt,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldvt | |||
| real(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | iwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
SGESDD computes the singular value decomposition (SVD) of a real M-by-N matrix A, optionally computing the left and right singular vectors. If singular vectors are desired, it uses a divide-and-conquer algorithm. The SVD is written A = U * SIGMA * transpose(V) where SIGMA is an M-by-N matrix which is zero except for its min(m,n) diagonal elements, U is an M-by-M orthogonal matrix, and V is an N-by-N orthogonal matrix. The diagonal elements of SIGMA are the singular values of A; they are real and non-negative, and are returned in descending order. The first min(m,n) columns of U and V are the left and right singular vectors of A. Note that the routine returns VT = V**T, not V. The divide and conquer algorithm makes very mild assumptions about floating point arithmetic. It will work on machines with a guard digit in add/subtract, or on those binary machines without guard digits which subtract like the Cray X-MP, Cray Y-MP, Cray C-90, or Cray-2. It could conceivably fail on hexadecimal or decimal machines without guard digits, but we know of none.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | jobz | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=sp), | intent(out) | :: | s(*) | |||
| real(kind=sp), | intent(out) | :: | u(ldu,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldu | |||
| real(kind=sp), | intent(out) | :: | vt(ldvt,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldvt | |||
| real(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | iwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
ZGESDD computes the singular value decomposition (SVD) of a complex M-by-N matrix A, optionally computing the left and/or right singular vectors, by using divide-and-conquer method. The SVD is written A = U * SIGMA * conjugate-transpose(V) where SIGMA is an M-by-N matrix which is zero except for its min(m,n) diagonal elements, U is an M-by-M unitary matrix, and V is an N-by-N unitary matrix. The diagonal elements of SIGMA are the singular values of A; they are real and non-negative, and are returned in descending order. The first min(m,n) columns of U and V are the left and right singular vectors of A. Note that the routine returns VT = V**H, not V. The divide and conquer algorithm makes very mild assumptions about floating point arithmetic. It will work on machines with a guard digit in add/subtract, or on those binary machines without guard digits which subtract like the Cray X-MP, Cray Y-MP, Cray C-90, or Cray-2. It could conceivably fail on hexadecimal or decimal machines without guard digits, but we know of none.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | jobz | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=dp), | intent(out) | :: | s(*) | |||
| complex(kind=dp), | intent(out) | :: | u(ldu,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldu | |||
| complex(kind=dp), | intent(out) | :: | vt(ldvt,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldvt | |||
| complex(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| real(kind=dp), | intent(out) | :: | rwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | iwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
GESV computes the solution to a complex system of linear equations A * X = B, where A is an N-by-N matrix and X and B are N-by-NRHS matrices. The LU decomposition with partial pivoting and row interchanges is used to factor A as A = P * L * U, where P is a permutation matrix, L is unit lower triangular, and U is upper triangular. The factored form of A is then used to solve the system of equations A * X = B.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| complex(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| integer(kind=ilp), | intent(out) | :: | ipiv(*) | |||
| complex(kind=sp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| real(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| integer(kind=ilp), | intent(out) | :: | ipiv(*) | |||
| real(kind=dp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| real(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| integer(kind=ilp), | intent(out) | :: | ipiv(*) | |||
| real(kind=sp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| complex(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| integer(kind=ilp), | intent(out) | :: | ipiv(*) | |||
| complex(kind=dp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| integer(kind=ilp), | intent(out) | :: | info |
CGESV computes the solution to a complex system of linear equations A * X = B, where A is an N-by-N matrix and X and B are N-by-NRHS matrices. The LU decomposition with partial pivoting and row interchanges is used to factor A as A = P * L * U, where P is a permutation matrix, L is unit lower triangular, and U is upper triangular. The factored form of A is then used to solve the system of equations A * X = B.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| complex(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| integer(kind=ilp), | intent(out) | :: | ipiv(*) | |||
| complex(kind=sp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| integer(kind=ilp), | intent(out) | :: | info |
DGESV computes the solution to a real system of linear equations A * X = B, where A is an N-by-N matrix and X and B are N-by-NRHS matrices. The LU decomposition with partial pivoting and row interchanges is used to factor A as A = P * L * U, where P is a permutation matrix, L is unit lower triangular, and U is upper triangular. The factored form of A is then used to solve the system of equations A * X = B.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| real(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| integer(kind=ilp), | intent(out) | :: | ipiv(*) | |||
| real(kind=dp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| integer(kind=ilp), | intent(out) | :: | info |
SGESV computes the solution to a real system of linear equations A * X = B, where A is an N-by-N matrix and X and B are N-by-NRHS matrices. The LU decomposition with partial pivoting and row interchanges is used to factor A as A = P * L * U, where P is a permutation matrix, L is unit lower triangular, and U is upper triangular. The factored form of A is then used to solve the system of equations A * X = B.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| real(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| integer(kind=ilp), | intent(out) | :: | ipiv(*) | |||
| real(kind=sp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| integer(kind=ilp), | intent(out) | :: | info |
ZGESV computes the solution to a complex system of linear equations A * X = B, where A is an N-by-N matrix and X and B are N-by-NRHS matrices. The LU decomposition with partial pivoting and row interchanges is used to factor A as A = P * L * U, where P is a permutation matrix, L is unit lower triangular, and U is upper triangular. The factored form of A is then used to solve the system of equations A * X = B.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| complex(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| integer(kind=ilp), | intent(out) | :: | ipiv(*) | |||
| complex(kind=dp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| integer(kind=ilp), | intent(out) | :: | info |
GESVD computes the singular value decomposition (SVD) of a complex M-by-N matrix A, optionally computing the left and/or right singular vectors. The SVD is written A = U * SIGMA * conjugate-transpose(V) where SIGMA is an M-by-N matrix which is zero except for its min(m,n) diagonal elements, U is an M-by-M unitary matrix, and V is an N-by-N unitary matrix. The diagonal elements of SIGMA are the singular values of A; they are real and non-negative, and are returned in descending order. The first min(m,n) columns of U and V are the left and right singular vectors of A. Note that the routine returns V**H, not V.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | jobu | |||
| character, | intent(in) | :: | jobvt | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=sp), | intent(out) | :: | s(*) | |||
| complex(kind=sp), | intent(out) | :: | u(ldu,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldu | |||
| complex(kind=sp), | intent(out) | :: | vt(ldvt,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldvt | |||
| complex(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| real(kind=sp), | intent(out) | :: | rwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | jobu | |||
| character, | intent(in) | :: | jobvt | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=dp), | intent(out) | :: | s(*) | |||
| real(kind=dp), | intent(out) | :: | u(ldu,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldu | |||
| real(kind=dp), | intent(out) | :: | vt(ldvt,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldvt | |||
| real(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | jobu | |||
| character, | intent(in) | :: | jobvt | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=sp), | intent(out) | :: | s(*) | |||
| real(kind=sp), | intent(out) | :: | u(ldu,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldu | |||
| real(kind=sp), | intent(out) | :: | vt(ldvt,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldvt | |||
| real(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | jobu | |||
| character, | intent(in) | :: | jobvt | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=dp), | intent(out) | :: | s(*) | |||
| complex(kind=dp), | intent(out) | :: | u(ldu,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldu | |||
| complex(kind=dp), | intent(out) | :: | vt(ldvt,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldvt | |||
| complex(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| real(kind=dp), | intent(out) | :: | rwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
CGESVD computes the singular value decomposition (SVD) of a complex M-by-N matrix A, optionally computing the left and/or right singular vectors. The SVD is written A = U * SIGMA * conjugate-transpose(V) where SIGMA is an M-by-N matrix which is zero except for its min(m,n) diagonal elements, U is an M-by-M unitary matrix, and V is an N-by-N unitary matrix. The diagonal elements of SIGMA are the singular values of A; they are real and non-negative, and are returned in descending order. The first min(m,n) columns of U and V are the left and right singular vectors of A. Note that the routine returns V**H, not V.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | jobu | |||
| character, | intent(in) | :: | jobvt | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=sp), | intent(out) | :: | s(*) | |||
| complex(kind=sp), | intent(out) | :: | u(ldu,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldu | |||
| complex(kind=sp), | intent(out) | :: | vt(ldvt,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldvt | |||
| complex(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| real(kind=sp), | intent(out) | :: | rwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
DGESVD computes the singular value decomposition (SVD) of a real M-by-N matrix A, optionally computing the left and/or right singular vectors. The SVD is written A = U * SIGMA * transpose(V) where SIGMA is an M-by-N matrix which is zero except for its min(m,n) diagonal elements, U is an M-by-M orthogonal matrix, and V is an N-by-N orthogonal matrix. The diagonal elements of SIGMA are the singular values of A; they are real and non-negative, and are returned in descending order. The first min(m,n) columns of U and V are the left and right singular vectors of A. Note that the routine returns V**T, not V.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | jobu | |||
| character, | intent(in) | :: | jobvt | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=dp), | intent(out) | :: | s(*) | |||
| real(kind=dp), | intent(out) | :: | u(ldu,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldu | |||
| real(kind=dp), | intent(out) | :: | vt(ldvt,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldvt | |||
| real(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
SGESVD computes the singular value decomposition (SVD) of a real M-by-N matrix A, optionally computing the left and/or right singular vectors. The SVD is written A = U * SIGMA * transpose(V) where SIGMA is an M-by-N matrix which is zero except for its min(m,n) diagonal elements, U is an M-by-M orthogonal matrix, and V is an N-by-N orthogonal matrix. The diagonal elements of SIGMA are the singular values of A; they are real and non-negative, and are returned in descending order. The first min(m,n) columns of U and V are the left and right singular vectors of A. Note that the routine returns V**T, not V.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | jobu | |||
| character, | intent(in) | :: | jobvt | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=sp), | intent(out) | :: | s(*) | |||
| real(kind=sp), | intent(out) | :: | u(ldu,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldu | |||
| real(kind=sp), | intent(out) | :: | vt(ldvt,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldvt | |||
| real(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
ZGESVD computes the singular value decomposition (SVD) of a complex M-by-N matrix A, optionally computing the left and/or right singular vectors. The SVD is written A = U * SIGMA * conjugate-transpose(V) where SIGMA is an M-by-N matrix which is zero except for its min(m,n) diagonal elements, U is an M-by-M unitary matrix, and V is an N-by-N unitary matrix. The diagonal elements of SIGMA are the singular values of A; they are real and non-negative, and are returned in descending order. The first min(m,n) columns of U and V are the left and right singular vectors of A. Note that the routine returns V**H, not V.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | jobu | |||
| character, | intent(in) | :: | jobvt | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=dp), | intent(out) | :: | s(*) | |||
| complex(kind=dp), | intent(out) | :: | u(ldu,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldu | |||
| complex(kind=dp), | intent(out) | :: | vt(ldvt,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldvt | |||
| complex(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| real(kind=dp), | intent(out) | :: | rwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
GESVDQ computes the singular value decomposition (SVD) of a complex M-by-N matrix A, where M >= N. The SVD of A is written as [++] [xx] [x0] [xx] A = U * SIGMA * V^*, [++] = [xx] * [ox] * [xx] [++] [xx] where SIGMA is an N-by-N diagonal matrix, U is an M-by-N orthonormal matrix, and V is an N-by-N unitary matrix. The diagonal elements of SIGMA are the singular values of A. The columns of U and V are the left and the right singular vectors of A, respectively.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | joba | |||
| character, | intent(in) | :: | jobp | |||
| character, | intent(in) | :: | jobr | |||
| character, | intent(in) | :: | jobu | |||
| character, | intent(in) | :: | jobv | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=sp), | intent(out) | :: | s(*) | |||
| complex(kind=sp), | intent(out) | :: | u(ldu,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldu | |||
| complex(kind=sp), | intent(out) | :: | v(ldv,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldv | |||
| integer(kind=ilp), | intent(out) | :: | numrank | |||
| integer(kind=ilp), | intent(out) | :: | iwork(*) | |||
| integer(kind=ilp), | intent(in) | :: | liwork | |||
| complex(kind=sp), | intent(out) | :: | cwork(*) | |||
| integer(kind=ilp), | intent(inout) | :: | lcwork | |||
| real(kind=sp), | intent(out) | :: | rwork(*) | |||
| integer(kind=ilp), | intent(in) | :: | lrwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | joba | |||
| character, | intent(in) | :: | jobp | |||
| character, | intent(in) | :: | jobr | |||
| character, | intent(in) | :: | jobu | |||
| character, | intent(in) | :: | jobv | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=dp), | intent(out) | :: | s(*) | |||
| real(kind=dp), | intent(out) | :: | u(ldu,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldu | |||
| real(kind=dp), | intent(out) | :: | v(ldv,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldv | |||
| integer(kind=ilp), | intent(out) | :: | numrank | |||
| integer(kind=ilp), | intent(out) | :: | iwork(*) | |||
| integer(kind=ilp), | intent(in) | :: | liwork | |||
| real(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(inout) | :: | lwork | |||
| real(kind=dp), | intent(out) | :: | rwork(*) | |||
| integer(kind=ilp), | intent(in) | :: | lrwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | joba | |||
| character, | intent(in) | :: | jobp | |||
| character, | intent(in) | :: | jobr | |||
| character, | intent(in) | :: | jobu | |||
| character, | intent(in) | :: | jobv | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=sp), | intent(out) | :: | s(*) | |||
| real(kind=sp), | intent(out) | :: | u(ldu,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldu | |||
| real(kind=sp), | intent(out) | :: | v(ldv,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldv | |||
| integer(kind=ilp), | intent(out) | :: | numrank | |||
| integer(kind=ilp), | intent(out) | :: | iwork(*) | |||
| integer(kind=ilp), | intent(in) | :: | liwork | |||
| real(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(inout) | :: | lwork | |||
| real(kind=sp), | intent(out) | :: | rwork(*) | |||
| integer(kind=ilp), | intent(in) | :: | lrwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | joba | |||
| character, | intent(in) | :: | jobp | |||
| character, | intent(in) | :: | jobr | |||
| character, | intent(in) | :: | jobu | |||
| character, | intent(in) | :: | jobv | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=dp), | intent(out) | :: | s(*) | |||
| complex(kind=dp), | intent(out) | :: | u(ldu,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldu | |||
| complex(kind=dp), | intent(out) | :: | v(ldv,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldv | |||
| integer(kind=ilp), | intent(out) | :: | numrank | |||
| integer(kind=ilp), | intent(out) | :: | iwork(*) | |||
| integer(kind=ilp), | intent(in) | :: | liwork | |||
| complex(kind=dp), | intent(out) | :: | cwork(*) | |||
| integer(kind=ilp), | intent(inout) | :: | lcwork | |||
| real(kind=dp), | intent(out) | :: | rwork(*) | |||
| integer(kind=ilp), | intent(in) | :: | lrwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
CGESVDQ computes the singular value decomposition (SVD) of a complex M-by-N matrix A, where M >= N. The SVD of A is written as [++] [xx] [x0] [xx] A = U * SIGMA * V^*, [++] = [xx] * [ox] * [xx] [++] [xx] where SIGMA is an N-by-N diagonal matrix, U is an M-by-N orthonormal matrix, and V is an N-by-N unitary matrix. The diagonal elements of SIGMA are the singular values of A. The columns of U and V are the left and the right singular vectors of A, respectively.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | joba | |||
| character, | intent(in) | :: | jobp | |||
| character, | intent(in) | :: | jobr | |||
| character, | intent(in) | :: | jobu | |||
| character, | intent(in) | :: | jobv | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=sp), | intent(out) | :: | s(*) | |||
| complex(kind=sp), | intent(out) | :: | u(ldu,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldu | |||
| complex(kind=sp), | intent(out) | :: | v(ldv,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldv | |||
| integer(kind=ilp), | intent(out) | :: | numrank | |||
| integer(kind=ilp), | intent(out) | :: | iwork(*) | |||
| integer(kind=ilp), | intent(in) | :: | liwork | |||
| complex(kind=sp), | intent(out) | :: | cwork(*) | |||
| integer(kind=ilp), | intent(inout) | :: | lcwork | |||
| real(kind=sp), | intent(out) | :: | rwork(*) | |||
| integer(kind=ilp), | intent(in) | :: | lrwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
DGESVDQ computes the singular value decomposition (SVD) of a real M-by-N matrix A, where M >= N. The SVD of A is written as [++] [xx] [x0] [xx] A = U * SIGMA * V^*, [++] = [xx] * [ox] * [xx] [++] [xx] where SIGMA is an N-by-N diagonal matrix, U is an M-by-N orthonormal matrix, and V is an N-by-N orthogonal matrix. The diagonal elements of SIGMA are the singular values of A. The columns of U and V are the left and the right singular vectors of A, respectively.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | joba | |||
| character, | intent(in) | :: | jobp | |||
| character, | intent(in) | :: | jobr | |||
| character, | intent(in) | :: | jobu | |||
| character, | intent(in) | :: | jobv | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=dp), | intent(out) | :: | s(*) | |||
| real(kind=dp), | intent(out) | :: | u(ldu,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldu | |||
| real(kind=dp), | intent(out) | :: | v(ldv,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldv | |||
| integer(kind=ilp), | intent(out) | :: | numrank | |||
| integer(kind=ilp), | intent(out) | :: | iwork(*) | |||
| integer(kind=ilp), | intent(in) | :: | liwork | |||
| real(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(inout) | :: | lwork | |||
| real(kind=dp), | intent(out) | :: | rwork(*) | |||
| integer(kind=ilp), | intent(in) | :: | lrwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
SGESVDQ computes the singular value decomposition (SVD) of a real M-by-N matrix A, where M >= N. The SVD of A is written as [++] [xx] [x0] [xx] A = U * SIGMA * V^*, [++] = [xx] * [ox] * [xx] [++] [xx] where SIGMA is an N-by-N diagonal matrix, U is an M-by-N orthonormal matrix, and V is an N-by-N orthogonal matrix. The diagonal elements of SIGMA are the singular values of A. The columns of U and V are the left and the right singular vectors of A, respectively.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | joba | |||
| character, | intent(in) | :: | jobp | |||
| character, | intent(in) | :: | jobr | |||
| character, | intent(in) | :: | jobu | |||
| character, | intent(in) | :: | jobv | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=sp), | intent(out) | :: | s(*) | |||
| real(kind=sp), | intent(out) | :: | u(ldu,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldu | |||
| real(kind=sp), | intent(out) | :: | v(ldv,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldv | |||
| integer(kind=ilp), | intent(out) | :: | numrank | |||
| integer(kind=ilp), | intent(out) | :: | iwork(*) | |||
| integer(kind=ilp), | intent(in) | :: | liwork | |||
| real(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(inout) | :: | lwork | |||
| real(kind=sp), | intent(out) | :: | rwork(*) | |||
| integer(kind=ilp), | intent(in) | :: | lrwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
ZCGESVDQ computes the singular value decomposition (SVD) of a complex M-by-N matrix A, where M >= N. The SVD of A is written as [++] [xx] [x0] [xx] A = U * SIGMA * V^*, [++] = [xx] * [ox] * [xx] [++] [xx] where SIGMA is an N-by-N diagonal matrix, U is an M-by-N orthonormal matrix, and V is an N-by-N unitary matrix. The diagonal elements of SIGMA are the singular values of A. The columns of U and V are the left and the right singular vectors of A, respectively.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | joba | |||
| character, | intent(in) | :: | jobp | |||
| character, | intent(in) | :: | jobr | |||
| character, | intent(in) | :: | jobu | |||
| character, | intent(in) | :: | jobv | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=dp), | intent(out) | :: | s(*) | |||
| complex(kind=dp), | intent(out) | :: | u(ldu,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldu | |||
| complex(kind=dp), | intent(out) | :: | v(ldv,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldv | |||
| integer(kind=ilp), | intent(out) | :: | numrank | |||
| integer(kind=ilp), | intent(out) | :: | iwork(*) | |||
| integer(kind=ilp), | intent(in) | :: | liwork | |||
| complex(kind=dp), | intent(out) | :: | cwork(*) | |||
| integer(kind=ilp), | intent(inout) | :: | lcwork | |||
| real(kind=dp), | intent(out) | :: | rwork(*) | |||
| integer(kind=ilp), | intent(in) | :: | lrwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
GESVJ computes the singular value decomposition (SVD) of a complex M-by-N matrix A, where M >= N. The SVD of A is written as [++] [xx] [x0] [xx] A = U * SIGMA * V^*, [++] = [xx] * [ox] * [xx] [++] [xx] where SIGMA is an N-by-N diagonal matrix, U is an M-by-N orthonormal matrix, and V is an N-by-N unitary matrix. The diagonal elements of SIGMA are the singular values of A. The columns of U and V are the left and the right singular vectors of A, respectively.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | joba | |||
| character, | intent(in) | :: | jobu | |||
| character, | intent(in) | :: | jobv | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=sp), | intent(out) | :: | sva(n) | |||
| integer(kind=ilp), | intent(in) | :: | mv | |||
| complex(kind=sp), | intent(inout) | :: | v(ldv,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldv | |||
| complex(kind=sp), | intent(inout) | :: | cwork(lwork) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| real(kind=sp), | intent(inout) | :: | rwork(lrwork) | |||
| integer(kind=ilp), | intent(in) | :: | lrwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | joba | |||
| character, | intent(in) | :: | jobu | |||
| character, | intent(in) | :: | jobv | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=dp), | intent(out) | :: | sva(n) | |||
| integer(kind=ilp), | intent(in) | :: | mv | |||
| real(kind=dp), | intent(inout) | :: | v(ldv,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldv | |||
| real(kind=dp), | intent(inout) | :: | work(lwork) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | joba | |||
| character, | intent(in) | :: | jobu | |||
| character, | intent(in) | :: | jobv | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=sp), | intent(out) | :: | sva(n) | |||
| integer(kind=ilp), | intent(in) | :: | mv | |||
| real(kind=sp), | intent(inout) | :: | v(ldv,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldv | |||
| real(kind=sp), | intent(inout) | :: | work(lwork) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | joba | |||
| character, | intent(in) | :: | jobu | |||
| character, | intent(in) | :: | jobv | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=dp), | intent(out) | :: | sva(n) | |||
| integer(kind=ilp), | intent(in) | :: | mv | |||
| complex(kind=dp), | intent(inout) | :: | v(ldv,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldv | |||
| complex(kind=dp), | intent(inout) | :: | cwork(lwork) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| real(kind=dp), | intent(inout) | :: | rwork(lrwork) | |||
| integer(kind=ilp), | intent(in) | :: | lrwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
CGESVJ computes the singular value decomposition (SVD) of a complex M-by-N matrix A, where M >= N. The SVD of A is written as [++] [xx] [x0] [xx] A = U * SIGMA * V^*, [++] = [xx] * [ox] * [xx] [++] [xx] where SIGMA is an N-by-N diagonal matrix, U is an M-by-N orthonormal matrix, and V is an N-by-N unitary matrix. The diagonal elements of SIGMA are the singular values of A. The columns of U and V are the left and the right singular vectors of A, respectively.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | joba | |||
| character, | intent(in) | :: | jobu | |||
| character, | intent(in) | :: | jobv | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=sp), | intent(out) | :: | sva(n) | |||
| integer(kind=ilp), | intent(in) | :: | mv | |||
| complex(kind=sp), | intent(inout) | :: | v(ldv,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldv | |||
| complex(kind=sp), | intent(inout) | :: | cwork(lwork) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| real(kind=sp), | intent(inout) | :: | rwork(lrwork) | |||
| integer(kind=ilp), | intent(in) | :: | lrwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
DGESVJ computes the singular value decomposition (SVD) of a real M-by-N matrix A, where M >= N. The SVD of A is written as [++] [xx] [x0] [xx] A = U * SIGMA * V^t, [++] = [xx] * [ox] * [xx] [++] [xx] where SIGMA is an N-by-N diagonal matrix, U is an M-by-N orthonormal matrix, and V is an N-by-N orthogonal matrix. The diagonal elements of SIGMA are the singular values of A. The columns of U and V are the left and the right singular vectors of A, respectively. DGESVJ can sometimes compute tiny singular values and their singular vectors much more accurately than other SVD routines, see below under Further Details.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | joba | |||
| character, | intent(in) | :: | jobu | |||
| character, | intent(in) | :: | jobv | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=dp), | intent(out) | :: | sva(n) | |||
| integer(kind=ilp), | intent(in) | :: | mv | |||
| real(kind=dp), | intent(inout) | :: | v(ldv,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldv | |||
| real(kind=dp), | intent(inout) | :: | work(lwork) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
SGESVJ computes the singular value decomposition (SVD) of a real M-by-N matrix A, where M >= N. The SVD of A is written as [++] [xx] [x0] [xx] A = U * SIGMA * V^t, [++] = [xx] * [ox] * [xx] [++] [xx] where SIGMA is an N-by-N diagonal matrix, U is an M-by-N orthonormal matrix, and V is an N-by-N orthogonal matrix. The diagonal elements of SIGMA are the singular values of A. The columns of U and V are the left and the right singular vectors of A, respectively. SGESVJ can sometimes compute tiny singular values and their singular vectors much more accurately than other SVD routines, see below under Further Details.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | joba | |||
| character, | intent(in) | :: | jobu | |||
| character, | intent(in) | :: | jobv | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=sp), | intent(out) | :: | sva(n) | |||
| integer(kind=ilp), | intent(in) | :: | mv | |||
| real(kind=sp), | intent(inout) | :: | v(ldv,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldv | |||
| real(kind=sp), | intent(inout) | :: | work(lwork) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
ZGESVJ computes the singular value decomposition (SVD) of a complex M-by-N matrix A, where M >= N. The SVD of A is written as [++] [xx] [x0] [xx] A = U * SIGMA * V^*, [++] = [xx] * [ox] * [xx] [++] [xx] where SIGMA is an N-by-N diagonal matrix, U is an M-by-N orthonormal matrix, and V is an N-by-N unitary matrix. The diagonal elements of SIGMA are the singular values of A. The columns of U and V are the left and the right singular vectors of A, respectively.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | joba | |||
| character, | intent(in) | :: | jobu | |||
| character, | intent(in) | :: | jobv | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=dp), | intent(out) | :: | sva(n) | |||
| integer(kind=ilp), | intent(in) | :: | mv | |||
| complex(kind=dp), | intent(inout) | :: | v(ldv,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldv | |||
| complex(kind=dp), | intent(inout) | :: | cwork(lwork) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| real(kind=dp), | intent(inout) | :: | rwork(lrwork) | |||
| integer(kind=ilp), | intent(in) | :: | lrwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
GETRF computes an LU factorization of a general M-by-N matrix A using partial pivoting with row interchanges. The factorization has the form A = P * L * U where P is a permutation matrix, L is lower triangular with unit diagonal elements (lower trapezoidal if m > n), and U is upper triangular (upper trapezoidal if m < n). This is the right-looking Level 3 BLAS version of the algorithm.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| integer(kind=ilp), | intent(out) | :: | ipiv(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| integer(kind=ilp), | intent(out) | :: | ipiv(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| integer(kind=ilp), | intent(out) | :: | ipiv(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| integer(kind=ilp), | intent(out) | :: | ipiv(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
CGETRF computes an LU factorization of a general M-by-N matrix A using partial pivoting with row interchanges. The factorization has the form A = P * L * U where P is a permutation matrix, L is lower triangular with unit diagonal elements (lower trapezoidal if m > n), and U is upper triangular (upper trapezoidal if m < n). This is the right-looking Level 3 BLAS version of the algorithm.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| integer(kind=ilp), | intent(out) | :: | ipiv(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
DGETRF computes an LU factorization of a general M-by-N matrix A using partial pivoting with row interchanges. The factorization has the form A = P * L * U where P is a permutation matrix, L is lower triangular with unit diagonal elements (lower trapezoidal if m > n), and U is upper triangular (upper trapezoidal if m < n). This is the right-looking Level 3 BLAS version of the algorithm.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| integer(kind=ilp), | intent(out) | :: | ipiv(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
SGETRF computes an LU factorization of a general M-by-N matrix A using partial pivoting with row interchanges. The factorization has the form A = P * L * U where P is a permutation matrix, L is lower triangular with unit diagonal elements (lower trapezoidal if m > n), and U is upper triangular (upper trapezoidal if m < n). This is the right-looking Level 3 BLAS version of the algorithm.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| integer(kind=ilp), | intent(out) | :: | ipiv(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
ZGETRF computes an LU factorization of a general M-by-N matrix A using partial pivoting with row interchanges. The factorization has the form A = P * L * U where P is a permutation matrix, L is lower triangular with unit diagonal elements (lower trapezoidal if m > n), and U is upper triangular (upper trapezoidal if m < n). This is the right-looking Level 3 BLAS version of the algorithm.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| integer(kind=ilp), | intent(out) | :: | ipiv(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
GETRF2 computes an LU factorization of a general M-by-N matrix A using partial pivoting with row interchanges. The factorization has the form A = P * L * U where P is a permutation matrix, L is lower triangular with unit diagonal elements (lower trapezoidal if m > n), and U is upper triangular (upper trapezoidal if m < n). This is the recursive version of the algorithm. It divides the matrix into four submatrices: [ A11 | A12 ] where A11 is n1 by n1 and A22 is n2 by n2 A = [ -----|----- ] with n1 = min(m,n)/2 [ A21 | A22 ] n2 = n-n1 [ A11 ] The subroutine calls itself to factor [ --- ], [ A12 ] [ A12 ] do the swaps on [ --- ], solve A12, update A22, [ A22 ] then calls itself to factor A22 and do the swaps on A21.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| integer(kind=ilp), | intent(out) | :: | ipiv(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| integer(kind=ilp), | intent(out) | :: | ipiv(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| integer(kind=ilp), | intent(out) | :: | ipiv(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| integer(kind=ilp), | intent(out) | :: | ipiv(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
CGETRF2 computes an LU factorization of a general M-by-N matrix A using partial pivoting with row interchanges. The factorization has the form A = P * L * U where P is a permutation matrix, L is lower triangular with unit diagonal elements (lower trapezoidal if m > n), and U is upper triangular (upper trapezoidal if m < n). This is the recursive version of the algorithm. It divides the matrix into four submatrices: [ A11 | A12 ] where A11 is n1 by n1 and A22 is n2 by n2 A = [ -----|----- ] with n1 = min(m,n)/2 [ A21 | A22 ] n2 = n-n1 [ A11 ] The subroutine calls itself to factor [ --- ], [ A12 ] [ A12 ] do the swaps on [ --- ], solve A12, update A22, [ A22 ] then calls itself to factor A22 and do the swaps on A21.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| integer(kind=ilp), | intent(out) | :: | ipiv(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
DGETRF2 computes an LU factorization of a general M-by-N matrix A using partial pivoting with row interchanges. The factorization has the form A = P * L * U where P is a permutation matrix, L is lower triangular with unit diagonal elements (lower trapezoidal if m > n), and U is upper triangular (upper trapezoidal if m < n). This is the recursive version of the algorithm. It divides the matrix into four submatrices: [ A11 | A12 ] where A11 is n1 by n1 and A22 is n2 by n2 A = [ -----|----- ] with n1 = min(m,n)/2 [ A21 | A22 ] n2 = n-n1 [ A11 ] The subroutine calls itself to factor [ --- ], [ A12 ] [ A12 ] do the swaps on [ --- ], solve A12, update A22, [ A22 ] then calls itself to factor A22 and do the swaps on A21.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| integer(kind=ilp), | intent(out) | :: | ipiv(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
SGETRF2 computes an LU factorization of a general M-by-N matrix A using partial pivoting with row interchanges. The factorization has the form A = P * L * U where P is a permutation matrix, L is lower triangular with unit diagonal elements (lower trapezoidal if m > n), and U is upper triangular (upper trapezoidal if m < n). This is the recursive version of the algorithm. It divides the matrix into four submatrices: [ A11 | A12 ] where A11 is n1 by n1 and A22 is n2 by n2 A = [ -----|----- ] with n1 = min(m,n)/2 [ A21 | A22 ] n2 = n-n1 [ A11 ] The subroutine calls itself to factor [ --- ], [ A12 ] [ A12 ] do the swaps on [ --- ], solve A12, update A22, [ A22 ] then calls itself to factor A22 and do the swaps on A21.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| integer(kind=ilp), | intent(out) | :: | ipiv(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
ZGETRF2 computes an LU factorization of a general M-by-N matrix A using partial pivoting with row interchanges. The factorization has the form A = P * L * U where P is a permutation matrix, L is lower triangular with unit diagonal elements (lower trapezoidal if m > n), and U is upper triangular (upper trapezoidal if m < n). This is the recursive version of the algorithm. It divides the matrix into four submatrices: [ A11 | A12 ] where A11 is n1 by n1 and A22 is n2 by n2 A = [ -----|----- ] with n1 = min(m,n)/2 [ A21 | A22 ] n2 = n-n1 [ A11 ] The subroutine calls itself to factor [ --- ], [ A12 ] [ A12 ] do the swaps on [ --- ], solve A12, update A22, [ A22 ] then calls itself to factor A22 and do the swaps on A21.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| integer(kind=ilp), | intent(out) | :: | ipiv(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
GETRI computes the inverse of a matrix using the LU factorization computed by CGETRF. This method inverts U and then computes inv(A) by solving the system inv(A)*L = inv(U) for inv(A).
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| integer(kind=ilp), | intent(in) | :: | ipiv(*) | |||
| complex(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| integer(kind=ilp), | intent(in) | :: | ipiv(*) | |||
| real(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| integer(kind=ilp), | intent(in) | :: | ipiv(*) | |||
| real(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| integer(kind=ilp), | intent(in) | :: | ipiv(*) | |||
| complex(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
CGETRI computes the inverse of a matrix using the LU factorization computed by CGETRF. This method inverts U and then computes inv(A) by solving the system inv(A)*L = inv(U) for inv(A).
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| integer(kind=ilp), | intent(in) | :: | ipiv(*) | |||
| complex(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
DGETRI computes the inverse of a matrix using the LU factorization computed by DGETRF. This method inverts U and then computes inv(A) by solving the system inv(A)*L = inv(U) for inv(A).
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| integer(kind=ilp), | intent(in) | :: | ipiv(*) | |||
| real(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
SGETRI computes the inverse of a matrix using the LU factorization computed by SGETRF. This method inverts U and then computes inv(A) by solving the system inv(A)*L = inv(U) for inv(A).
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| integer(kind=ilp), | intent(in) | :: | ipiv(*) | |||
| real(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
ZGETRI computes the inverse of a matrix using the LU factorization computed by ZGETRF. This method inverts U and then computes inv(A) by solving the system inv(A)*L = inv(U) for inv(A).
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| integer(kind=ilp), | intent(in) | :: | ipiv(*) | |||
| complex(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
GETRS solves a system of linear equations A * X = B, AT * X = B, or AH * X = B with a general N-by-N matrix A using the LU factorization computed by CGETRF.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | trans | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| complex(kind=sp), | intent(in) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| integer(kind=ilp), | intent(in) | :: | ipiv(*) | |||
| complex(kind=sp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | trans | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| real(kind=dp), | intent(in) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| integer(kind=ilp), | intent(in) | :: | ipiv(*) | |||
| real(kind=dp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | trans | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| real(kind=sp), | intent(in) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| integer(kind=ilp), | intent(in) | :: | ipiv(*) | |||
| real(kind=sp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | trans | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| complex(kind=dp), | intent(in) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| integer(kind=ilp), | intent(in) | :: | ipiv(*) | |||
| complex(kind=dp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| integer(kind=ilp), | intent(out) | :: | info |
CGETRS solves a system of linear equations A * X = B, AT * X = B, or AH * X = B with a general N-by-N matrix A using the LU factorization computed by CGETRF.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | trans | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| complex(kind=sp), | intent(in) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| integer(kind=ilp), | intent(in) | :: | ipiv(*) | |||
| complex(kind=sp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| integer(kind=ilp), | intent(out) | :: | info |
DGETRS solves a system of linear equations A * X = B or A**T * X = B with a general N-by-N matrix A using the LU factorization computed by DGETRF.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | trans | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| real(kind=dp), | intent(in) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| integer(kind=ilp), | intent(in) | :: | ipiv(*) | |||
| real(kind=dp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| integer(kind=ilp), | intent(out) | :: | info |
SGETRS solves a system of linear equations A * X = B or A**T * X = B with a general N-by-N matrix A using the LU factorization computed by SGETRF.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | trans | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| real(kind=sp), | intent(in) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| integer(kind=ilp), | intent(in) | :: | ipiv(*) | |||
| real(kind=sp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| integer(kind=ilp), | intent(out) | :: | info |
ZGETRS solves a system of linear equations A * X = B, AT * X = B, or AH * X = B with a general N-by-N matrix A using the LU factorization computed by ZGETRF.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | trans | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| complex(kind=dp), | intent(in) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| integer(kind=ilp), | intent(in) | :: | ipiv(*) | |||
| complex(kind=dp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| integer(kind=ilp), | intent(out) | :: | info |
GETSLS solves overdetermined or underdetermined complex linear systems involving an M-by-N matrix A, using a tall skinny QR or short wide LQ factorization of A. It is assumed that A has full rank. The following options are provided: 1. If TRANS = 'N' and m >= n: find the least squares solution of an overdetermined system, i.e., solve the least squares problem minimize || B - AX ||. 2. If TRANS = 'N' and m < n: find the minimum norm solution of an underdetermined system A * X = B. 3. If TRANS = 'C' and m >= n: find the minimum norm solution of an undetermined system AT * X = B. 4. If TRANS = 'C' and m < n: find the least squares solution of an overdetermined system, i.e., solve the least squares problem minimize || B - A*T * X ||. Several right hand side vectors b and solution vectors x can be handled in a single call; they are stored as the columns of the M-by-NRHS right hand side matrix B and the N-by-NRHS solution matrix X.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | trans | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| complex(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=sp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| complex(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | trans | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| real(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=dp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| real(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | trans | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| real(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=sp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| real(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | trans | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| complex(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=dp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| complex(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
CGETSLS solves overdetermined or underdetermined complex linear systems involving an M-by-N matrix A, using a tall skinny QR or short wide LQ factorization of A. It is assumed that A has full rank. The following options are provided: 1. If TRANS = 'N' and m >= n: find the least squares solution of an overdetermined system, i.e., solve the least squares problem minimize || B - AX ||. 2. If TRANS = 'N' and m < n: find the minimum norm solution of an underdetermined system A * X = B. 3. If TRANS = 'C' and m >= n: find the minimum norm solution of an undetermined system AT * X = B. 4. If TRANS = 'C' and m < n: find the least squares solution of an overdetermined system, i.e., solve the least squares problem minimize || B - A*T * X ||. Several right hand side vectors b and solution vectors x can be handled in a single call; they are stored as the columns of the M-by-NRHS right hand side matrix B and the N-by-NRHS solution matrix X.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | trans | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| complex(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=sp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| complex(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
DGETSLS solves overdetermined or underdetermined real linear systems involving an M-by-N matrix A, using a tall skinny QR or short wide LQ factorization of A. It is assumed that A has full rank. The following options are provided: 1. If TRANS = 'N' and m >= n: find the least squares solution of an overdetermined system, i.e., solve the least squares problem minimize || B - AX ||. 2. If TRANS = 'N' and m < n: find the minimum norm solution of an underdetermined system A * X = B. 3. If TRANS = 'T' and m >= n: find the minimum norm solution of an undetermined system AT * X = B. 4. If TRANS = 'T' and m < n: find the least squares solution of an overdetermined system, i.e., solve the least squares problem minimize || B - A*T * X ||. Several right hand side vectors b and solution vectors x can be handled in a single call; they are stored as the columns of the M-by-NRHS right hand side matrix B and the N-by-NRHS solution matrix X.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | trans | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| real(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=dp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| real(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
SGETSLS solves overdetermined or underdetermined real linear systems involving an M-by-N matrix A, using a tall skinny QR or short wide LQ factorization of A. It is assumed that A has full rank. The following options are provided: 1. If TRANS = 'N' and m >= n: find the least squares solution of an overdetermined system, i.e., solve the least squares problem minimize || B - AX ||. 2. If TRANS = 'N' and m < n: find the minimum norm solution of an underdetermined system A * X = B. 3. If TRANS = 'T' and m >= n: find the minimum norm solution of an undetermined system AT * X = B. 4. If TRANS = 'T' and m < n: find the least squares solution of an overdetermined system, i.e., solve the least squares problem minimize || B - A*T * X ||. Several right hand side vectors b and solution vectors x can be handled in a single call; they are stored as the columns of the M-by-NRHS right hand side matrix B and the N-by-NRHS solution matrix X.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | trans | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| real(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=sp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| real(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
ZGETSLS solves overdetermined or underdetermined complex linear systems involving an M-by-N matrix A, using a tall skinny QR or short wide LQ factorization of A. It is assumed that A has full rank. The following options are provided: 1. If TRANS = 'N' and m >= n: find the least squares solution of an overdetermined system, i.e., solve the least squares problem minimize || B - AX ||. 2. If TRANS = 'N' and m < n: find the minimum norm solution of an underdetermined system A * X = B. 3. If TRANS = 'C' and m >= n: find the minimum norm solution of an undetermined system AT * X = B. 4. If TRANS = 'C' and m < n: find the least squares solution of an overdetermined system, i.e., solve the least squares problem minimize || B - A*T * X ||. Several right hand side vectors b and solution vectors x can be handled in a single call; they are stored as the columns of the M-by-NRHS right hand side matrix B and the N-by-NRHS solution matrix X.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | trans | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| complex(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=dp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| complex(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
GETSQRHRT computes a NB2-sized column blocked QR-factorization of a complex M-by-N matrix A with M >= N, A = Q * R. The routine uses internally a NB1-sized column blocked and MB1-sized row blocked TSQR-factorization and perfors the reconstruction of the Householder vectors from the TSQR output. The routine also converts the R_tsqr factor from the TSQR-factorization output into the R factor that corresponds to the Householder QR-factorization, A = Q_tsqr * R_tsqr = Q * R. The output Q and R factors are stored in the same format as in CGEQRT (Q is in blocked compact WY-representation). See the documentation of CGEQRT for more details on the format.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | mb1 | |||
| integer(kind=ilp), | intent(in) | :: | nb1 | |||
| integer(kind=ilp), | intent(in) | :: | nb2 | |||
| complex(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=sp), | intent(out) | :: | t(ldt,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldt | |||
| complex(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | mb1 | |||
| integer(kind=ilp), | intent(in) | :: | nb1 | |||
| integer(kind=ilp), | intent(in) | :: | nb2 | |||
| real(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=dp), | intent(out) | :: | t(ldt,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldt | |||
| real(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | mb1 | |||
| integer(kind=ilp), | intent(in) | :: | nb1 | |||
| integer(kind=ilp), | intent(in) | :: | nb2 | |||
| real(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=sp), | intent(out) | :: | t(ldt,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldt | |||
| real(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | mb1 | |||
| integer(kind=ilp), | intent(in) | :: | nb1 | |||
| integer(kind=ilp), | intent(in) | :: | nb2 | |||
| complex(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=dp), | intent(out) | :: | t(ldt,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldt | |||
| complex(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
CGETSQRHRT computes a NB2-sized column blocked QR-factorization of a complex M-by-N matrix A with M >= N, A = Q * R. The routine uses internally a NB1-sized column blocked and MB1-sized row blocked TSQR-factorization and perfors the reconstruction of the Householder vectors from the TSQR output. The routine also converts the R_tsqr factor from the TSQR-factorization output into the R factor that corresponds to the Householder QR-factorization, A = Q_tsqr * R_tsqr = Q * R. The output Q and R factors are stored in the same format as in CGEQRT (Q is in blocked compact WY-representation). See the documentation of CGEQRT for more details on the format.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | mb1 | |||
| integer(kind=ilp), | intent(in) | :: | nb1 | |||
| integer(kind=ilp), | intent(in) | :: | nb2 | |||
| complex(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=sp), | intent(out) | :: | t(ldt,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldt | |||
| complex(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
DGETSQRHRT computes a NB2-sized column blocked QR-factorization of a real M-by-N matrix A with M >= N, A = Q * R. The routine uses internally a NB1-sized column blocked and MB1-sized row blocked TSQR-factorization and perfors the reconstruction of the Householder vectors from the TSQR output. The routine also converts the R_tsqr factor from the TSQR-factorization output into the R factor that corresponds to the Householder QR-factorization, A = Q_tsqr * R_tsqr = Q * R. The output Q and R factors are stored in the same format as in DGEQRT (Q is in blocked compact WY-representation). See the documentation of DGEQRT for more details on the format.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | mb1 | |||
| integer(kind=ilp), | intent(in) | :: | nb1 | |||
| integer(kind=ilp), | intent(in) | :: | nb2 | |||
| real(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=dp), | intent(out) | :: | t(ldt,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldt | |||
| real(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
SGETSQRHRT computes a NB2-sized column blocked QR-factorization of a complex M-by-N matrix A with M >= N, A = Q * R. The routine uses internally a NB1-sized column blocked and MB1-sized row blocked TSQR-factorization and perfors the reconstruction of the Householder vectors from the TSQR output. The routine also converts the R_tsqr factor from the TSQR-factorization output into the R factor that corresponds to the Householder QR-factorization, A = Q_tsqr * R_tsqr = Q * R. The output Q and R factors are stored in the same format as in SGEQRT (Q is in blocked compact WY-representation). See the documentation of SGEQRT for more details on the format.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | mb1 | |||
| integer(kind=ilp), | intent(in) | :: | nb1 | |||
| integer(kind=ilp), | intent(in) | :: | nb2 | |||
| real(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=sp), | intent(out) | :: | t(ldt,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldt | |||
| real(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
ZGETSQRHRT computes a NB2-sized column blocked QR-factorization of a complex M-by-N matrix A with M >= N, A = Q * R. The routine uses internally a NB1-sized column blocked and MB1-sized row blocked TSQR-factorization and perfors the reconstruction of the Householder vectors from the TSQR output. The routine also converts the R_tsqr factor from the TSQR-factorization output into the R factor that corresponds to the Householder QR-factorization, A = Q_tsqr * R_tsqr = Q * R. The output Q and R factors are stored in the same format as in ZGEQRT (Q is in blocked compact WY-representation). See the documentation of ZGEQRT for more details on the format.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | mb1 | |||
| integer(kind=ilp), | intent(in) | :: | nb1 | |||
| integer(kind=ilp), | intent(in) | :: | nb2 | |||
| complex(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=dp), | intent(out) | :: | t(ldt,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldt | |||
| complex(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
GGBAK forms the right or left eigenvectors of a complex generalized eigenvalue problem Ax = lambdaB*x, by backward transformation on the computed eigenvectors of the balanced pair of matrices output by CGGBAL.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | job | |||
| character, | intent(in) | :: | side | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | ilo | |||
| integer(kind=ilp), | intent(in) | :: | ihi | |||
| real(kind=sp), | intent(in) | :: | lscale(*) | |||
| real(kind=sp), | intent(in) | :: | rscale(*) | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| complex(kind=sp), | intent(inout) | :: | v(ldv,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldv | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | job | |||
| character, | intent(in) | :: | side | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | ilo | |||
| integer(kind=ilp), | intent(in) | :: | ihi | |||
| real(kind=dp), | intent(in) | :: | lscale(*) | |||
| real(kind=dp), | intent(in) | :: | rscale(*) | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| real(kind=dp), | intent(inout) | :: | v(ldv,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldv | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | job | |||
| character, | intent(in) | :: | side | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | ilo | |||
| integer(kind=ilp), | intent(in) | :: | ihi | |||
| real(kind=sp), | intent(in) | :: | lscale(*) | |||
| real(kind=sp), | intent(in) | :: | rscale(*) | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| real(kind=sp), | intent(inout) | :: | v(ldv,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldv | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | job | |||
| character, | intent(in) | :: | side | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | ilo | |||
| integer(kind=ilp), | intent(in) | :: | ihi | |||
| real(kind=dp), | intent(in) | :: | lscale(*) | |||
| real(kind=dp), | intent(in) | :: | rscale(*) | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| complex(kind=dp), | intent(inout) | :: | v(ldv,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldv | |||
| integer(kind=ilp), | intent(out) | :: | info |
CGGBAK forms the right or left eigenvectors of a complex generalized eigenvalue problem Ax = lambdaB*x, by backward transformation on the computed eigenvectors of the balanced pair of matrices output by CGGBAL.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | job | |||
| character, | intent(in) | :: | side | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | ilo | |||
| integer(kind=ilp), | intent(in) | :: | ihi | |||
| real(kind=sp), | intent(in) | :: | lscale(*) | |||
| real(kind=sp), | intent(in) | :: | rscale(*) | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| complex(kind=sp), | intent(inout) | :: | v(ldv,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldv | |||
| integer(kind=ilp), | intent(out) | :: | info |
DGGBAK forms the right or left eigenvectors of a real generalized eigenvalue problem Ax = lambdaB*x, by backward transformation on the computed eigenvectors of the balanced pair of matrices output by DGGBAL.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | job | |||
| character, | intent(in) | :: | side | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | ilo | |||
| integer(kind=ilp), | intent(in) | :: | ihi | |||
| real(kind=dp), | intent(in) | :: | lscale(*) | |||
| real(kind=dp), | intent(in) | :: | rscale(*) | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| real(kind=dp), | intent(inout) | :: | v(ldv,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldv | |||
| integer(kind=ilp), | intent(out) | :: | info |
SGGBAK forms the right or left eigenvectors of a real generalized eigenvalue problem Ax = lambdaB*x, by backward transformation on the computed eigenvectors of the balanced pair of matrices output by SGGBAL.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | job | |||
| character, | intent(in) | :: | side | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | ilo | |||
| integer(kind=ilp), | intent(in) | :: | ihi | |||
| real(kind=sp), | intent(in) | :: | lscale(*) | |||
| real(kind=sp), | intent(in) | :: | rscale(*) | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| real(kind=sp), | intent(inout) | :: | v(ldv,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldv | |||
| integer(kind=ilp), | intent(out) | :: | info |
ZGGBAK forms the right or left eigenvectors of a complex generalized eigenvalue problem Ax = lambdaB*x, by backward transformation on the computed eigenvectors of the balanced pair of matrices output by ZGGBAL.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | job | |||
| character, | intent(in) | :: | side | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | ilo | |||
| integer(kind=ilp), | intent(in) | :: | ihi | |||
| real(kind=dp), | intent(in) | :: | lscale(*) | |||
| real(kind=dp), | intent(in) | :: | rscale(*) | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| complex(kind=dp), | intent(inout) | :: | v(ldv,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldv | |||
| integer(kind=ilp), | intent(out) | :: | info |
GGBAL balances a pair of general complex matrices (A,B). This involves, first, permuting A and B by similarity transformations to isolate eigenvalues in the first 1 to ILO$-$1 and last IHI+1 to N elements on the diagonal; and second, applying a diagonal similarity transformation to rows and columns ILO to IHI to make the rows and columns as close in norm as possible. Both steps are optional. Balancing may reduce the 1-norm of the matrices, and improve the accuracy of the computed eigenvalues and/or eigenvectors in the generalized eigenvalue problem Ax = lambdaB*x.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | job | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=sp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| integer(kind=ilp), | intent(out) | :: | ilo | |||
| integer(kind=ilp), | intent(out) | :: | ihi | |||
| real(kind=sp), | intent(out) | :: | lscale(*) | |||
| real(kind=sp), | intent(out) | :: | rscale(*) | |||
| real(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | job | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=dp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| integer(kind=ilp), | intent(out) | :: | ilo | |||
| integer(kind=ilp), | intent(out) | :: | ihi | |||
| real(kind=dp), | intent(out) | :: | lscale(*) | |||
| real(kind=dp), | intent(out) | :: | rscale(*) | |||
| real(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | job | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=sp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| integer(kind=ilp), | intent(out) | :: | ilo | |||
| integer(kind=ilp), | intent(out) | :: | ihi | |||
| real(kind=sp), | intent(out) | :: | lscale(*) | |||
| real(kind=sp), | intent(out) | :: | rscale(*) | |||
| real(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | job | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=dp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| integer(kind=ilp), | intent(out) | :: | ilo | |||
| integer(kind=ilp), | intent(out) | :: | ihi | |||
| real(kind=dp), | intent(out) | :: | lscale(*) | |||
| real(kind=dp), | intent(out) | :: | rscale(*) | |||
| real(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
CGGBAL balances a pair of general complex matrices (A,B). This involves, first, permuting A and B by similarity transformations to isolate eigenvalues in the first 1 to ILO$-$1 and last IHI+1 to N elements on the diagonal; and second, applying a diagonal similarity transformation to rows and columns ILO to IHI to make the rows and columns as close in norm as possible. Both steps are optional. Balancing may reduce the 1-norm of the matrices, and improve the accuracy of the computed eigenvalues and/or eigenvectors in the generalized eigenvalue problem Ax = lambdaB*x.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | job | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=sp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| integer(kind=ilp), | intent(out) | :: | ilo | |||
| integer(kind=ilp), | intent(out) | :: | ihi | |||
| real(kind=sp), | intent(out) | :: | lscale(*) | |||
| real(kind=sp), | intent(out) | :: | rscale(*) | |||
| real(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
DGGBAL balances a pair of general real matrices (A,B). This involves, first, permuting A and B by similarity transformations to isolate eigenvalues in the first 1 to ILO$-$1 and last IHI+1 to N elements on the diagonal; and second, applying a diagonal similarity transformation to rows and columns ILO to IHI to make the rows and columns as close in norm as possible. Both steps are optional. Balancing may reduce the 1-norm of the matrices, and improve the accuracy of the computed eigenvalues and/or eigenvectors in the generalized eigenvalue problem Ax = lambdaB*x.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | job | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=dp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| integer(kind=ilp), | intent(out) | :: | ilo | |||
| integer(kind=ilp), | intent(out) | :: | ihi | |||
| real(kind=dp), | intent(out) | :: | lscale(*) | |||
| real(kind=dp), | intent(out) | :: | rscale(*) | |||
| real(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
SGGBAL balances a pair of general real matrices (A,B). This involves, first, permuting A and B by similarity transformations to isolate eigenvalues in the first 1 to ILO$-$1 and last IHI+1 to N elements on the diagonal; and second, applying a diagonal similarity transformation to rows and columns ILO to IHI to make the rows and columns as close in norm as possible. Both steps are optional. Balancing may reduce the 1-norm of the matrices, and improve the accuracy of the computed eigenvalues and/or eigenvectors in the generalized eigenvalue problem Ax = lambdaB*x.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | job | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=sp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| integer(kind=ilp), | intent(out) | :: | ilo | |||
| integer(kind=ilp), | intent(out) | :: | ihi | |||
| real(kind=sp), | intent(out) | :: | lscale(*) | |||
| real(kind=sp), | intent(out) | :: | rscale(*) | |||
| real(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
ZGGBAL balances a pair of general complex matrices (A,B). This involves, first, permuting A and B by similarity transformations to isolate eigenvalues in the first 1 to ILO$-$1 and last IHI+1 to N elements on the diagonal; and second, applying a diagonal similarity transformation to rows and columns ILO to IHI to make the rows and columns as close in norm as possible. Both steps are optional. Balancing may reduce the 1-norm of the matrices, and improve the accuracy of the computed eigenvalues and/or eigenvectors in the generalized eigenvalue problem Ax = lambdaB*x.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | job | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=dp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| integer(kind=ilp), | intent(out) | :: | ilo | |||
| integer(kind=ilp), | intent(out) | :: | ihi | |||
| real(kind=dp), | intent(out) | :: | lscale(*) | |||
| real(kind=dp), | intent(out) | :: | rscale(*) | |||
| real(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
GGES computes for a pair of N-by-N complex nonsymmetric matrices (A,B), the generalized eigenvalues, the generalized complex Schur form (S, T), and optionally left and/or right Schur vectors (VSL and VSR). This gives the generalized Schur factorization (A,B) = ( (VSL)S(VSR)H, (VSL)T(VSR)H ) where (VSR)*H is the conjugate-transpose of VSR. Optionally, it also orders the eigenvalues so that a selected cluster of eigenvalues appears in the leading diagonal blocks of the upper triangular matrix S and the upper triangular matrix T. The leading columns of VSL and VSR then form an unitary basis for the corresponding left and right eigenspaces (deflating subspaces). (If only the generalized eigenvalues are needed, use the driver CGGEV instead, which is faster.) A generalized eigenvalue for a pair of matrices (A,B) is a scalar w or a ratio alpha/beta = w, such that A - wB is singular. It is usually represented as the pair (alpha,beta), as there is a reasonable interpretation for beta=0, and even for both being zero. A pair of matrices (S,T) is in generalized complex Schur form if S and T are upper triangular and, in addition, the diagonal elements of T are non-negative real numbers.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | jobvsl | |||
| character, | intent(in) | :: | jobvsr | |||
| character, | intent(in) | :: | sort | |||
| procedure(stdlib_selctg_c) | :: | selctg | ||||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=sp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| integer(kind=ilp), | intent(out) | :: | sdim | |||
| complex(kind=sp), | intent(out) | :: | alpha(*) | |||
| complex(kind=sp), | intent(out) | :: | beta(*) | |||
| complex(kind=sp), | intent(out) | :: | vsl(ldvsl,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldvsl | |||
| complex(kind=sp), | intent(out) | :: | vsr(ldvsr,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldvsr | |||
| complex(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| real(kind=sp), | intent(out) | :: | rwork(*) | |||
| logical(kind=lk), | intent(out) | :: | bwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | jobvsl | |||
| character, | intent(in) | :: | jobvsr | |||
| character, | intent(in) | :: | sort | |||
| procedure(stdlib_selctg_d) | :: | selctg | ||||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=dp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| integer(kind=ilp), | intent(out) | :: | sdim | |||
| real(kind=dp), | intent(out) | :: | alphar(*) | |||
| real(kind=dp), | intent(out) | :: | alphai(*) | |||
| real(kind=dp), | intent(out) | :: | beta(*) | |||
| real(kind=dp), | intent(out) | :: | vsl(ldvsl,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldvsl | |||
| real(kind=dp), | intent(out) | :: | vsr(ldvsr,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldvsr | |||
| real(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| logical(kind=lk), | intent(out) | :: | bwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | jobvsl | |||
| character, | intent(in) | :: | jobvsr | |||
| character, | intent(in) | :: | sort | |||
| procedure(stdlib_selctg_s) | :: | selctg | ||||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=sp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| integer(kind=ilp), | intent(out) | :: | sdim | |||
| real(kind=sp), | intent(out) | :: | alphar(*) | |||
| real(kind=sp), | intent(out) | :: | alphai(*) | |||
| real(kind=sp), | intent(out) | :: | beta(*) | |||
| real(kind=sp), | intent(out) | :: | vsl(ldvsl,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldvsl | |||
| real(kind=sp), | intent(out) | :: | vsr(ldvsr,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldvsr | |||
| real(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| logical(kind=lk), | intent(out) | :: | bwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | jobvsl | |||
| character, | intent(in) | :: | jobvsr | |||
| character, | intent(in) | :: | sort | |||
| procedure(stdlib_selctg_z) | :: | selctg | ||||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=dp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| integer(kind=ilp), | intent(out) | :: | sdim | |||
| complex(kind=dp), | intent(out) | :: | alpha(*) | |||
| complex(kind=dp), | intent(out) | :: | beta(*) | |||
| complex(kind=dp), | intent(out) | :: | vsl(ldvsl,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldvsl | |||
| complex(kind=dp), | intent(out) | :: | vsr(ldvsr,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldvsr | |||
| complex(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| real(kind=dp), | intent(out) | :: | rwork(*) | |||
| logical(kind=lk), | intent(out) | :: | bwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
CGGES computes for a pair of N-by-N complex nonsymmetric matrices (A,B), the generalized eigenvalues, the generalized complex Schur form (S, T), and optionally left and/or right Schur vectors (VSL and VSR). This gives the generalized Schur factorization (A,B) = ( (VSL)S(VSR)H, (VSL)T(VSR)H ) where (VSR)*H is the conjugate-transpose of VSR. Optionally, it also orders the eigenvalues so that a selected cluster of eigenvalues appears in the leading diagonal blocks of the upper triangular matrix S and the upper triangular matrix T. The leading columns of VSL and VSR then form an unitary basis for the corresponding left and right eigenspaces (deflating subspaces). (If only the generalized eigenvalues are needed, use the driver CGGEV instead, which is faster.) A generalized eigenvalue for a pair of matrices (A,B) is a scalar w or a ratio alpha/beta = w, such that A - wB is singular. It is usually represented as the pair (alpha,beta), as there is a reasonable interpretation for beta=0, and even for both being zero. A pair of matrices (S,T) is in generalized complex Schur form if S and T are upper triangular and, in addition, the diagonal elements of T are non-negative real numbers.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | jobvsl | |||
| character, | intent(in) | :: | jobvsr | |||
| character, | intent(in) | :: | sort | |||
| procedure(stdlib_selctg_c) | :: | selctg | ||||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=sp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| integer(kind=ilp), | intent(out) | :: | sdim | |||
| complex(kind=sp), | intent(out) | :: | alpha(*) | |||
| complex(kind=sp), | intent(out) | :: | beta(*) | |||
| complex(kind=sp), | intent(out) | :: | vsl(ldvsl,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldvsl | |||
| complex(kind=sp), | intent(out) | :: | vsr(ldvsr,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldvsr | |||
| complex(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| real(kind=sp), | intent(out) | :: | rwork(*) | |||
| logical(kind=lk), | intent(out) | :: | bwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
DGGES computes for a pair of N-by-N real nonsymmetric matrices (A,B), the generalized eigenvalues, the generalized real Schur form (S,T), optionally, the left and/or right matrices of Schur vectors (VSL and VSR). This gives the generalized Schur factorization (A,B) = ( (VSL)S(VSR)T, (VSL)T(VSR)T ) Optionally, it also orders the eigenvalues so that a selected cluster of eigenvalues appears in the leading diagonal blocks of the upper quasi-triangular matrix S and the upper triangular matrix T.The leading columns of VSL and VSR then form an orthonormal basis for the corresponding left and right eigenspaces (deflating subspaces). (If only the generalized eigenvalues are needed, use the driver DGGEV instead, which is faster.) A generalized eigenvalue for a pair of matrices (A,B) is a scalar w or a ratio alpha/beta = w, such that A - w*B is singular. It is usually represented as the pair (alpha,beta), as there is a reasonable interpretation for beta=0 or both being zero. A pair of matrices (S,T) is in generalized real Schur form if T is upper triangular with non-negative diagonal and S is block upper triangular with 1-by-1 and 2-by-2 blocks. 1-by-1 blocks correspond to real generalized eigenvalues, while 2-by-2 blocks of S will be "standardized" by making the corresponding elements of T have the form: [ a 0 ] [ 0 b ] and the pair of corresponding 2-by-2 blocks in S and T will have a complex conjugate pair of generalized eigenvalues.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | jobvsl | |||
| character, | intent(in) | :: | jobvsr | |||
| character, | intent(in) | :: | sort | |||
| procedure(stdlib_selctg_d) | :: | selctg | ||||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=dp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| integer(kind=ilp), | intent(out) | :: | sdim | |||
| real(kind=dp), | intent(out) | :: | alphar(*) | |||
| real(kind=dp), | intent(out) | :: | alphai(*) | |||
| real(kind=dp), | intent(out) | :: | beta(*) | |||
| real(kind=dp), | intent(out) | :: | vsl(ldvsl,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldvsl | |||
| real(kind=dp), | intent(out) | :: | vsr(ldvsr,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldvsr | |||
| real(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| logical(kind=lk), | intent(out) | :: | bwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
SGGES computes for a pair of N-by-N real nonsymmetric matrices (A,B), the generalized eigenvalues, the generalized real Schur form (S,T), optionally, the left and/or right matrices of Schur vectors (VSL and VSR). This gives the generalized Schur factorization (A,B) = ( (VSL)S(VSR)T, (VSL)T(VSR)T ) Optionally, it also orders the eigenvalues so that a selected cluster of eigenvalues appears in the leading diagonal blocks of the upper quasi-triangular matrix S and the upper triangular matrix T.The leading columns of VSL and VSR then form an orthonormal basis for the corresponding left and right eigenspaces (deflating subspaces). (If only the generalized eigenvalues are needed, use the driver SGGEV instead, which is faster.) A generalized eigenvalue for a pair of matrices (A,B) is a scalar w or a ratio alpha/beta = w, such that A - w*B is singular. It is usually represented as the pair (alpha,beta), as there is a reasonable interpretation for beta=0 or both being zero. A pair of matrices (S,T) is in generalized real Schur form if T is upper triangular with non-negative diagonal and S is block upper triangular with 1-by-1 and 2-by-2 blocks. 1-by-1 blocks correspond to real generalized eigenvalues, while 2-by-2 blocks of S will be "standardized" by making the corresponding elements of T have the form: [ a 0 ] [ 0 b ] and the pair of corresponding 2-by-2 blocks in S and T will have a complex conjugate pair of generalized eigenvalues.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | jobvsl | |||
| character, | intent(in) | :: | jobvsr | |||
| character, | intent(in) | :: | sort | |||
| procedure(stdlib_selctg_s) | :: | selctg | ||||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=sp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| integer(kind=ilp), | intent(out) | :: | sdim | |||
| real(kind=sp), | intent(out) | :: | alphar(*) | |||
| real(kind=sp), | intent(out) | :: | alphai(*) | |||
| real(kind=sp), | intent(out) | :: | beta(*) | |||
| real(kind=sp), | intent(out) | :: | vsl(ldvsl,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldvsl | |||
| real(kind=sp), | intent(out) | :: | vsr(ldvsr,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldvsr | |||
| real(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| logical(kind=lk), | intent(out) | :: | bwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
ZGGES computes for a pair of N-by-N complex nonsymmetric matrices (A,B), the generalized eigenvalues, the generalized complex Schur form (S, T), and optionally left and/or right Schur vectors (VSL and VSR). This gives the generalized Schur factorization (A,B) = ( (VSL)S(VSR)H, (VSL)T(VSR)H ) where (VSR)*H is the conjugate-transpose of VSR. Optionally, it also orders the eigenvalues so that a selected cluster of eigenvalues appears in the leading diagonal blocks of the upper triangular matrix S and the upper triangular matrix T. The leading columns of VSL and VSR then form an unitary basis for the corresponding left and right eigenspaces (deflating subspaces). (If only the generalized eigenvalues are needed, use the driver ZGGEV instead, which is faster.) A generalized eigenvalue for a pair of matrices (A,B) is a scalar w or a ratio alpha/beta = w, such that A - wB is singular. It is usually represented as the pair (alpha,beta), as there is a reasonable interpretation for beta=0, and even for both being zero. A pair of matrices (S,T) is in generalized complex Schur form if S and T are upper triangular and, in addition, the diagonal elements of T are non-negative real numbers.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | jobvsl | |||
| character, | intent(in) | :: | jobvsr | |||
| character, | intent(in) | :: | sort | |||
| procedure(stdlib_selctg_z) | :: | selctg | ||||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=dp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| integer(kind=ilp), | intent(out) | :: | sdim | |||
| complex(kind=dp), | intent(out) | :: | alpha(*) | |||
| complex(kind=dp), | intent(out) | :: | beta(*) | |||
| complex(kind=dp), | intent(out) | :: | vsl(ldvsl,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldvsl | |||
| complex(kind=dp), | intent(out) | :: | vsr(ldvsr,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldvsr | |||
| complex(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| real(kind=dp), | intent(out) | :: | rwork(*) | |||
| logical(kind=lk), | intent(out) | :: | bwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
GGEV computes for a pair of N-by-N complex nonsymmetric matrices (A,B), the generalized eigenvalues, and optionally, the left and/or right generalized eigenvectors. A generalized eigenvalue for a pair of matrices (A,B) is a scalar lambda or a ratio alpha/beta = lambda, such that A - lambdaB is singular. It is usually represented as the pair (alpha,beta), as there is a reasonable interpretation for beta=0, and even for both being zero. The right generalized eigenvector v(j) corresponding to the generalized eigenvalue lambda(j) of (A,B) satisfies A * v(j) = lambda(j) * B * v(j). The left generalized eigenvector u(j) corresponding to the generalized eigenvalues lambda(j) of (A,B) satisfies u(j)H * A = lambda(j) * u(j)H * B where u(j)*H is the conjugate-transpose of u(j).
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | jobvl | |||
| character, | intent(in) | :: | jobvr | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=sp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| complex(kind=sp), | intent(out) | :: | alpha(*) | |||
| complex(kind=sp), | intent(out) | :: | beta(*) | |||
| complex(kind=sp), | intent(out) | :: | vl(ldvl,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldvl | |||
| complex(kind=sp), | intent(out) | :: | vr(ldvr,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldvr | |||
| complex(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| real(kind=sp), | intent(out) | :: | rwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | jobvl | |||
| character, | intent(in) | :: | jobvr | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=dp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| real(kind=dp), | intent(out) | :: | alphar(*) | |||
| real(kind=dp), | intent(out) | :: | alphai(*) | |||
| real(kind=dp), | intent(out) | :: | beta(*) | |||
| real(kind=dp), | intent(out) | :: | vl(ldvl,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldvl | |||
| real(kind=dp), | intent(out) | :: | vr(ldvr,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldvr | |||
| real(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | jobvl | |||
| character, | intent(in) | :: | jobvr | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=sp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| real(kind=sp), | intent(out) | :: | alphar(*) | |||
| real(kind=sp), | intent(out) | :: | alphai(*) | |||
| real(kind=sp), | intent(out) | :: | beta(*) | |||
| real(kind=sp), | intent(out) | :: | vl(ldvl,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldvl | |||
| real(kind=sp), | intent(out) | :: | vr(ldvr,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldvr | |||
| real(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | jobvl | |||
| character, | intent(in) | :: | jobvr | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=dp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| complex(kind=dp), | intent(out) | :: | alpha(*) | |||
| complex(kind=dp), | intent(out) | :: | beta(*) | |||
| complex(kind=dp), | intent(out) | :: | vl(ldvl,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldvl | |||
| complex(kind=dp), | intent(out) | :: | vr(ldvr,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldvr | |||
| complex(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| real(kind=dp), | intent(out) | :: | rwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
CGGEV computes for a pair of N-by-N complex nonsymmetric matrices (A,B), the generalized eigenvalues, and optionally, the left and/or right generalized eigenvectors. A generalized eigenvalue for a pair of matrices (A,B) is a scalar lambda or a ratio alpha/beta = lambda, such that A - lambdaB is singular. It is usually represented as the pair (alpha,beta), as there is a reasonable interpretation for beta=0, and even for both being zero. The right generalized eigenvector v(j) corresponding to the generalized eigenvalue lambda(j) of (A,B) satisfies A * v(j) = lambda(j) * B * v(j). The left generalized eigenvector u(j) corresponding to the generalized eigenvalues lambda(j) of (A,B) satisfies u(j)H * A = lambda(j) * u(j)H * B where u(j)*H is the conjugate-transpose of u(j).
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | jobvl | |||
| character, | intent(in) | :: | jobvr | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=sp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| complex(kind=sp), | intent(out) | :: | alpha(*) | |||
| complex(kind=sp), | intent(out) | :: | beta(*) | |||
| complex(kind=sp), | intent(out) | :: | vl(ldvl,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldvl | |||
| complex(kind=sp), | intent(out) | :: | vr(ldvr,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldvr | |||
| complex(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| real(kind=sp), | intent(out) | :: | rwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
DGGEV computes for a pair of N-by-N real nonsymmetric matrices (A,B) the generalized eigenvalues, and optionally, the left and/or right generalized eigenvectors. A generalized eigenvalue for a pair of matrices (A,B) is a scalar lambda or a ratio alpha/beta = lambda, such that A - lambdaB is singular. It is usually represented as the pair (alpha,beta), as there is a reasonable interpretation for beta=0, and even for both being zero. The right eigenvector v(j) corresponding to the eigenvalue lambda(j) of (A,B) satisfies A * v(j) = lambda(j) * B * v(j). The left eigenvector u(j) corresponding to the eigenvalue lambda(j) of (A,B) satisfies u(j)H * A = lambda(j) * u(j)H * B . where u(j)*H is the conjugate-transpose of u(j).
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | jobvl | |||
| character, | intent(in) | :: | jobvr | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=dp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| real(kind=dp), | intent(out) | :: | alphar(*) | |||
| real(kind=dp), | intent(out) | :: | alphai(*) | |||
| real(kind=dp), | intent(out) | :: | beta(*) | |||
| real(kind=dp), | intent(out) | :: | vl(ldvl,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldvl | |||
| real(kind=dp), | intent(out) | :: | vr(ldvr,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldvr | |||
| real(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
SGGEV computes for a pair of N-by-N real nonsymmetric matrices (A,B) the generalized eigenvalues, and optionally, the left and/or right generalized eigenvectors. A generalized eigenvalue for a pair of matrices (A,B) is a scalar lambda or a ratio alpha/beta = lambda, such that A - lambdaB is singular. It is usually represented as the pair (alpha,beta), as there is a reasonable interpretation for beta=0, and even for both being zero. The right eigenvector v(j) corresponding to the eigenvalue lambda(j) of (A,B) satisfies A * v(j) = lambda(j) * B * v(j). The left eigenvector u(j) corresponding to the eigenvalue lambda(j) of (A,B) satisfies u(j)H * A = lambda(j) * u(j)H * B . where u(j)*H is the conjugate-transpose of u(j).
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | jobvl | |||
| character, | intent(in) | :: | jobvr | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=sp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| real(kind=sp), | intent(out) | :: | alphar(*) | |||
| real(kind=sp), | intent(out) | :: | alphai(*) | |||
| real(kind=sp), | intent(out) | :: | beta(*) | |||
| real(kind=sp), | intent(out) | :: | vl(ldvl,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldvl | |||
| real(kind=sp), | intent(out) | :: | vr(ldvr,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldvr | |||
| real(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
ZGGEV computes for a pair of N-by-N complex nonsymmetric matrices (A,B), the generalized eigenvalues, and optionally, the left and/or right generalized eigenvectors. A generalized eigenvalue for a pair of matrices (A,B) is a scalar lambda or a ratio alpha/beta = lambda, such that A - lambdaB is singular. It is usually represented as the pair (alpha,beta), as there is a reasonable interpretation for beta=0, and even for both being zero. The right generalized eigenvector v(j) corresponding to the generalized eigenvalue lambda(j) of (A,B) satisfies A * v(j) = lambda(j) * B * v(j). The left generalized eigenvector u(j) corresponding to the generalized eigenvalues lambda(j) of (A,B) satisfies u(j)H * A = lambda(j) * u(j)H * B where u(j)*H is the conjugate-transpose of u(j).
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | jobvl | |||
| character, | intent(in) | :: | jobvr | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=dp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| complex(kind=dp), | intent(out) | :: | alpha(*) | |||
| complex(kind=dp), | intent(out) | :: | beta(*) | |||
| complex(kind=dp), | intent(out) | :: | vl(ldvl,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldvl | |||
| complex(kind=dp), | intent(out) | :: | vr(ldvr,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldvr | |||
| complex(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| real(kind=dp), | intent(out) | :: | rwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
GGGLM solves a general Gauss-Markov linear model (GLM) problem: minimize || y ||_2 subject to d = Ax + By x where A is an N-by-M matrix, B is an N-by-P matrix, and d is a given N-vector. It is assumed that M <= N <= M+P, and rank(A) = M and rank( A B ) = N. Under these assumptions, the constrained equation is always consistent, and there is a unique solution x and a minimal 2-norm solution y, which is obtained using a generalized QR factorization of the matrices (A, B) given by A = Q(R), B = QTZ. (0) In particular, if matrix B is square nonsingular, then the problem GLM is equivalent to the following weighted linear least squares problem minimize || inv(B)(d-A*x) ||_2 x where inv(B) denotes the inverse of B.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | p | |||
| complex(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=sp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| complex(kind=sp), | intent(inout) | :: | d(*) | |||
| complex(kind=sp), | intent(out) | :: | x(*) | |||
| complex(kind=sp), | intent(out) | :: | y(*) | |||
| complex(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | p | |||
| real(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=dp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| real(kind=dp), | intent(inout) | :: | d(*) | |||
| real(kind=dp), | intent(out) | :: | x(*) | |||
| real(kind=dp), | intent(out) | :: | y(*) | |||
| real(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | p | |||
| real(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=sp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| real(kind=sp), | intent(inout) | :: | d(*) | |||
| real(kind=sp), | intent(out) | :: | x(*) | |||
| real(kind=sp), | intent(out) | :: | y(*) | |||
| real(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | p | |||
| complex(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=dp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| complex(kind=dp), | intent(inout) | :: | d(*) | |||
| complex(kind=dp), | intent(out) | :: | x(*) | |||
| complex(kind=dp), | intent(out) | :: | y(*) | |||
| complex(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
CGGGLM solves a general Gauss-Markov linear model (GLM) problem: minimize || y ||_2 subject to d = Ax + By x where A is an N-by-M matrix, B is an N-by-P matrix, and d is a given N-vector. It is assumed that M <= N <= M+P, and rank(A) = M and rank( A B ) = N. Under these assumptions, the constrained equation is always consistent, and there is a unique solution x and a minimal 2-norm solution y, which is obtained using a generalized QR factorization of the matrices (A, B) given by A = Q(R), B = QTZ. (0) In particular, if matrix B is square nonsingular, then the problem GLM is equivalent to the following weighted linear least squares problem minimize || inv(B)(d-A*x) ||_2 x where inv(B) denotes the inverse of B.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | p | |||
| complex(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=sp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| complex(kind=sp), | intent(inout) | :: | d(*) | |||
| complex(kind=sp), | intent(out) | :: | x(*) | |||
| complex(kind=sp), | intent(out) | :: | y(*) | |||
| complex(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
DGGGLM solves a general Gauss-Markov linear model (GLM) problem: minimize || y ||_2 subject to d = Ax + By x where A is an N-by-M matrix, B is an N-by-P matrix, and d is a given N-vector. It is assumed that M <= N <= M+P, and rank(A) = M and rank( A B ) = N. Under these assumptions, the constrained equation is always consistent, and there is a unique solution x and a minimal 2-norm solution y, which is obtained using a generalized QR factorization of the matrices (A, B) given by A = Q(R), B = QTZ. (0) In particular, if matrix B is square nonsingular, then the problem GLM is equivalent to the following weighted linear least squares problem minimize || inv(B)(d-A*x) ||_2 x where inv(B) denotes the inverse of B.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | p | |||
| real(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=dp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| real(kind=dp), | intent(inout) | :: | d(*) | |||
| real(kind=dp), | intent(out) | :: | x(*) | |||
| real(kind=dp), | intent(out) | :: | y(*) | |||
| real(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
SGGGLM solves a general Gauss-Markov linear model (GLM) problem: minimize || y ||_2 subject to d = Ax + By x where A is an N-by-M matrix, B is an N-by-P matrix, and d is a given N-vector. It is assumed that M <= N <= M+P, and rank(A) = M and rank( A B ) = N. Under these assumptions, the constrained equation is always consistent, and there is a unique solution x and a minimal 2-norm solution y, which is obtained using a generalized QR factorization of the matrices (A, B) given by A = Q(R), B = QTZ. (0) In particular, if matrix B is square nonsingular, then the problem GLM is equivalent to the following weighted linear least squares problem minimize || inv(B)(d-A*x) ||_2 x where inv(B) denotes the inverse of B.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | p | |||
| real(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=sp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| real(kind=sp), | intent(inout) | :: | d(*) | |||
| real(kind=sp), | intent(out) | :: | x(*) | |||
| real(kind=sp), | intent(out) | :: | y(*) | |||
| real(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
ZGGGLM solves a general Gauss-Markov linear model (GLM) problem: minimize || y ||_2 subject to d = Ax + By x where A is an N-by-M matrix, B is an N-by-P matrix, and d is a given N-vector. It is assumed that M <= N <= M+P, and rank(A) = M and rank( A B ) = N. Under these assumptions, the constrained equation is always consistent, and there is a unique solution x and a minimal 2-norm solution y, which is obtained using a generalized QR factorization of the matrices (A, B) given by A = Q(R), B = QTZ. (0) In particular, if matrix B is square nonsingular, then the problem GLM is equivalent to the following weighted linear least squares problem minimize || inv(B)(d-A*x) ||_2 x where inv(B) denotes the inverse of B.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | p | |||
| complex(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=dp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| complex(kind=dp), | intent(inout) | :: | d(*) | |||
| complex(kind=dp), | intent(out) | :: | x(*) | |||
| complex(kind=dp), | intent(out) | :: | y(*) | |||
| complex(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
GGHRD reduces a pair of complex matrices (A,B) to generalized upper Hessenberg form using unitary transformations, where A is a general matrix and B is upper triangular. The form of the generalized eigenvalue problem is Ax = lambdaBx, and B is typically made upper triangular by computing its QR factorization and moving the unitary matrix Q to the left side of the equation. This subroutine simultaneously reduces A to a Hessenberg matrix H: QHAZ = H and transforms B to another upper triangular matrix T: QHBZ = T in order to reduce the problem to its standard form Hy = lambdaTy where y = ZH*x. The unitary matrices Q and Z are determined as products of Givens rotations. They may either be formed explicitly, or they may be postmultiplied into input matrices Q1 and Z1, so that Q1 * A * Z1H = (Q1Q) * H * (Z1Z)H Q1 * B * Z1H = (Q1Q) * T * (Z1Z)H If Q1 is the unitary matrix from the QR factorization of B in the original equation Ax = lambdaB*x, then GGHRD reduces the original problem to generalized Hessenberg form.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | compq | |||
| character, | intent(in) | :: | compz | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | ilo | |||
| integer(kind=ilp), | intent(in) | :: | ihi | |||
| complex(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=sp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| complex(kind=sp), | intent(inout) | :: | q(ldq,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldq | |||
| complex(kind=sp), | intent(inout) | :: | z(ldz,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldz | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | compq | |||
| character, | intent(in) | :: | compz | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | ilo | |||
| integer(kind=ilp), | intent(in) | :: | ihi | |||
| real(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=dp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| real(kind=dp), | intent(inout) | :: | q(ldq,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldq | |||
| real(kind=dp), | intent(inout) | :: | z(ldz,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldz | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | compq | |||
| character, | intent(in) | :: | compz | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | ilo | |||
| integer(kind=ilp), | intent(in) | :: | ihi | |||
| real(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=sp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| real(kind=sp), | intent(inout) | :: | q(ldq,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldq | |||
| real(kind=sp), | intent(inout) | :: | z(ldz,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldz | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | compq | |||
| character, | intent(in) | :: | compz | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | ilo | |||
| integer(kind=ilp), | intent(in) | :: | ihi | |||
| complex(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=dp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| complex(kind=dp), | intent(inout) | :: | q(ldq,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldq | |||
| complex(kind=dp), | intent(inout) | :: | z(ldz,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldz | |||
| integer(kind=ilp), | intent(out) | :: | info |
CGGHRD reduces a pair of complex matrices (A,B) to generalized upper Hessenberg form using unitary transformations, where A is a general matrix and B is upper triangular. The form of the generalized eigenvalue problem is Ax = lambdaBx, and B is typically made upper triangular by computing its QR factorization and moving the unitary matrix Q to the left side of the equation. This subroutine simultaneously reduces A to a Hessenberg matrix H: QHAZ = H and transforms B to another upper triangular matrix T: QHBZ = T in order to reduce the problem to its standard form Hy = lambdaTy where y = ZH*x. The unitary matrices Q and Z are determined as products of Givens rotations. They may either be formed explicitly, or they may be postmultiplied into input matrices Q1 and Z1, so that Q1 * A * Z1H = (Q1Q) * H * (Z1Z)H Q1 * B * Z1H = (Q1Q) * T * (Z1Z)H If Q1 is the unitary matrix from the QR factorization of B in the original equation Ax = lambdaB*x, then CGGHRD reduces the original problem to generalized Hessenberg form.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | compq | |||
| character, | intent(in) | :: | compz | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | ilo | |||
| integer(kind=ilp), | intent(in) | :: | ihi | |||
| complex(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=sp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| complex(kind=sp), | intent(inout) | :: | q(ldq,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldq | |||
| complex(kind=sp), | intent(inout) | :: | z(ldz,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldz | |||
| integer(kind=ilp), | intent(out) | :: | info |
DGGHRD reduces a pair of real matrices (A,B) to generalized upper Hessenberg form using orthogonal transformations, where A is a general matrix and B is upper triangular. The form of the generalized eigenvalue problem is Ax = lambdaBx, and B is typically made upper triangular by computing its QR factorization and moving the orthogonal matrix Q to the left side of the equation. This subroutine simultaneously reduces A to a Hessenberg matrix H: QTAZ = H and transforms B to another upper triangular matrix T: QTBZ = T in order to reduce the problem to its standard form Hy = lambdaTy where y = ZT*x. The orthogonal matrices Q and Z are determined as products of Givens rotations. They may either be formed explicitly, or they may be postmultiplied into input matrices Q1 and Z1, so that Q1 * A * Z1T = (Q1Q) * H * (Z1Z)T Q1 * B * Z1T = (Q1Q) * T * (Z1Z)T If Q1 is the orthogonal matrix from the QR factorization of B in the original equation Ax = lambdaB*x, then DGGHRD reduces the original problem to generalized Hessenberg form.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | compq | |||
| character, | intent(in) | :: | compz | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | ilo | |||
| integer(kind=ilp), | intent(in) | :: | ihi | |||
| real(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=dp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| real(kind=dp), | intent(inout) | :: | q(ldq,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldq | |||
| real(kind=dp), | intent(inout) | :: | z(ldz,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldz | |||
| integer(kind=ilp), | intent(out) | :: | info |
SGGHRD reduces a pair of real matrices (A,B) to generalized upper Hessenberg form using orthogonal transformations, where A is a general matrix and B is upper triangular. The form of the generalized eigenvalue problem is Ax = lambdaBx, and B is typically made upper triangular by computing its QR factorization and moving the orthogonal matrix Q to the left side of the equation. This subroutine simultaneously reduces A to a Hessenberg matrix H: QTAZ = H and transforms B to another upper triangular matrix T: QTBZ = T in order to reduce the problem to its standard form Hy = lambdaTy where y = ZT*x. The orthogonal matrices Q and Z are determined as products of Givens rotations. They may either be formed explicitly, or they may be postmultiplied into input matrices Q1 and Z1, so that Q1 * A * Z1T = (Q1Q) * H * (Z1Z)T Q1 * B * Z1T = (Q1Q) * T * (Z1Z)T If Q1 is the orthogonal matrix from the QR factorization of B in the original equation Ax = lambdaB*x, then SGGHRD reduces the original problem to generalized Hessenberg form.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | compq | |||
| character, | intent(in) | :: | compz | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | ilo | |||
| integer(kind=ilp), | intent(in) | :: | ihi | |||
| real(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=sp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| real(kind=sp), | intent(inout) | :: | q(ldq,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldq | |||
| real(kind=sp), | intent(inout) | :: | z(ldz,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldz | |||
| integer(kind=ilp), | intent(out) | :: | info |
ZGGHRD reduces a pair of complex matrices (A,B) to generalized upper Hessenberg form using unitary transformations, where A is a general matrix and B is upper triangular. The form of the generalized eigenvalue problem is Ax = lambdaBx, and B is typically made upper triangular by computing its QR factorization and moving the unitary matrix Q to the left side of the equation. This subroutine simultaneously reduces A to a Hessenberg matrix H: QHAZ = H and transforms B to another upper triangular matrix T: QHBZ = T in order to reduce the problem to its standard form Hy = lambdaTy where y = ZH*x. The unitary matrices Q and Z are determined as products of Givens rotations. They may either be formed explicitly, or they may be postmultiplied into input matrices Q1 and Z1, so that Q1 * A * Z1H = (Q1Q) * H * (Z1Z)H Q1 * B * Z1H = (Q1Q) * T * (Z1Z)H If Q1 is the unitary matrix from the QR factorization of B in the original equation Ax = lambdaB*x, then ZGGHRD reduces the original problem to generalized Hessenberg form.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | compq | |||
| character, | intent(in) | :: | compz | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | ilo | |||
| integer(kind=ilp), | intent(in) | :: | ihi | |||
| complex(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=dp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| complex(kind=dp), | intent(inout) | :: | q(ldq,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldq | |||
| complex(kind=dp), | intent(inout) | :: | z(ldz,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldz | |||
| integer(kind=ilp), | intent(out) | :: | info |
GGLSE solves the linear equality-constrained least squares (LSE) problem: minimize || c - Ax ||_2 subject to Bx = d where A is an M-by-N matrix, B is a P-by-N matrix, c is a given M-vector, and d is a given P-vector. It is assumed that P <= N <= M+P, and rank(B) = P and rank( (A) ) = N. ( (B) ) These conditions ensure that the LSE problem has a unique solution, which is obtained using a generalized RQ factorization of the matrices (B, A) given by B = (0 R)Q, A = ZT*Q.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | p | |||
| complex(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=sp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| complex(kind=sp), | intent(inout) | :: | c(*) | |||
| complex(kind=sp), | intent(inout) | :: | d(*) | |||
| complex(kind=sp), | intent(out) | :: | x(*) | |||
| complex(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | p | |||
| real(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=dp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| real(kind=dp), | intent(inout) | :: | c(*) | |||
| real(kind=dp), | intent(inout) | :: | d(*) | |||
| real(kind=dp), | intent(out) | :: | x(*) | |||
| real(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | p | |||
| real(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=sp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| real(kind=sp), | intent(inout) | :: | c(*) | |||
| real(kind=sp), | intent(inout) | :: | d(*) | |||
| real(kind=sp), | intent(out) | :: | x(*) | |||
| real(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | p | |||
| complex(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=dp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| complex(kind=dp), | intent(inout) | :: | c(*) | |||
| complex(kind=dp), | intent(inout) | :: | d(*) | |||
| complex(kind=dp), | intent(out) | :: | x(*) | |||
| complex(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
CGGLSE solves the linear equality-constrained least squares (LSE) problem: minimize || c - Ax ||_2 subject to Bx = d where A is an M-by-N matrix, B is a P-by-N matrix, c is a given M-vector, and d is a given P-vector. It is assumed that P <= N <= M+P, and rank(B) = P and rank( (A) ) = N. ( (B) ) These conditions ensure that the LSE problem has a unique solution, which is obtained using a generalized RQ factorization of the matrices (B, A) given by B = (0 R)Q, A = ZT*Q.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | p | |||
| complex(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=sp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| complex(kind=sp), | intent(inout) | :: | c(*) | |||
| complex(kind=sp), | intent(inout) | :: | d(*) | |||
| complex(kind=sp), | intent(out) | :: | x(*) | |||
| complex(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
DGGLSE solves the linear equality-constrained least squares (LSE) problem: minimize || c - Ax ||_2 subject to Bx = d where A is an M-by-N matrix, B is a P-by-N matrix, c is a given M-vector, and d is a given P-vector. It is assumed that P <= N <= M+P, and rank(B) = P and rank( (A) ) = N. ( (B) ) These conditions ensure that the LSE problem has a unique solution, which is obtained using a generalized RQ factorization of the matrices (B, A) given by B = (0 R)Q, A = ZT*Q.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | p | |||
| real(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=dp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| real(kind=dp), | intent(inout) | :: | c(*) | |||
| real(kind=dp), | intent(inout) | :: | d(*) | |||
| real(kind=dp), | intent(out) | :: | x(*) | |||
| real(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
SGGLSE solves the linear equality-constrained least squares (LSE) problem: minimize || c - Ax ||_2 subject to Bx = d where A is an M-by-N matrix, B is a P-by-N matrix, c is a given M-vector, and d is a given P-vector. It is assumed that P <= N <= M+P, and rank(B) = P and rank( (A) ) = N. ( (B) ) These conditions ensure that the LSE problem has a unique solution, which is obtained using a generalized RQ factorization of the matrices (B, A) given by B = (0 R)Q, A = ZT*Q.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | p | |||
| real(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=sp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| real(kind=sp), | intent(inout) | :: | c(*) | |||
| real(kind=sp), | intent(inout) | :: | d(*) | |||
| real(kind=sp), | intent(out) | :: | x(*) | |||
| real(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
ZGGLSE solves the linear equality-constrained least squares (LSE) problem: minimize || c - Ax ||_2 subject to Bx = d where A is an M-by-N matrix, B is a P-by-N matrix, c is a given M-vector, and d is a given P-vector. It is assumed that P <= N <= M+P, and rank(B) = P and rank( (A) ) = N. ( (B) ) These conditions ensure that the LSE problem has a unique solution, which is obtained using a generalized RQ factorization of the matrices (B, A) given by B = (0 R)Q, A = ZT*Q.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | p | |||
| complex(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=dp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| complex(kind=dp), | intent(inout) | :: | c(*) | |||
| complex(kind=dp), | intent(inout) | :: | d(*) | |||
| complex(kind=dp), | intent(out) | :: | x(*) | |||
| complex(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
GGQRF computes a generalized QR factorization of an N-by-M matrix A and an N-by-P matrix B: A = QR, B = QTZ, where Q is an N-by-N unitary matrix, Z is a P-by-P unitary matrix, and R and T assume one of the forms: if N >= M, R = ( R11 ) M , or if N < M, R = ( R11 R12 ) N, ( 0 ) N-M N M-N M where R11 is upper triangular, and if N <= P, T = ( 0 T12 ) N, or if N > P, T = ( T11 ) N-P, P-N N ( T21 ) P P where T12 or T21 is upper triangular. In particular, if B is square and nonsingular, the GQR factorization of A and B implicitly gives the QR factorization of inv(B)A: inv(B)A = ZH * (inv(T)R) where inv(B) denotes the inverse of the matrix B, and Z' denotes the conjugate transpose of matrix Z.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | p | |||
| complex(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=sp), | intent(out) | :: | taua(*) | |||
| complex(kind=sp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| complex(kind=sp), | intent(out) | :: | taub(*) | |||
| complex(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | p | |||
| real(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=dp), | intent(out) | :: | taua(*) | |||
| real(kind=dp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| real(kind=dp), | intent(out) | :: | taub(*) | |||
| real(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | p | |||
| real(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=sp), | intent(out) | :: | taua(*) | |||
| real(kind=sp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| real(kind=sp), | intent(out) | :: | taub(*) | |||
| real(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | p | |||
| complex(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=dp), | intent(out) | :: | taua(*) | |||
| complex(kind=dp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| complex(kind=dp), | intent(out) | :: | taub(*) | |||
| complex(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
CGGQRF computes a generalized QR factorization of an N-by-M matrix A and an N-by-P matrix B: A = QR, B = QTZ, where Q is an N-by-N unitary matrix, Z is a P-by-P unitary matrix, and R and T assume one of the forms: if N >= M, R = ( R11 ) M , or if N < M, R = ( R11 R12 ) N, ( 0 ) N-M N M-N M where R11 is upper triangular, and if N <= P, T = ( 0 T12 ) N, or if N > P, T = ( T11 ) N-P, P-N N ( T21 ) P P where T12 or T21 is upper triangular. In particular, if B is square and nonsingular, the GQR factorization of A and B implicitly gives the QR factorization of inv(B)A: inv(B)A = ZH * (inv(T)R) where inv(B) denotes the inverse of the matrix B, and Z' denotes the conjugate transpose of matrix Z.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | p | |||
| complex(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=sp), | intent(out) | :: | taua(*) | |||
| complex(kind=sp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| complex(kind=sp), | intent(out) | :: | taub(*) | |||
| complex(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
DGGQRF computes a generalized QR factorization of an N-by-M matrix A and an N-by-P matrix B: A = QR, B = QTZ, where Q is an N-by-N orthogonal matrix, Z is a P-by-P orthogonal matrix, and R and T assume one of the forms: if N >= M, R = ( R11 ) M , or if N < M, R = ( R11 R12 ) N, ( 0 ) N-M N M-N M where R11 is upper triangular, and if N <= P, T = ( 0 T12 ) N, or if N > P, T = ( T11 ) N-P, P-N N ( T21 ) P P where T12 or T21 is upper triangular. In particular, if B is square and nonsingular, the GQR factorization of A and B implicitly gives the QR factorization of inv(B)A: inv(B)A = ZT(inv(T)R) where inv(B) denotes the inverse of the matrix B, and Z*T denotes the transpose of the matrix Z.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | p | |||
| real(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=dp), | intent(out) | :: | taua(*) | |||
| real(kind=dp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| real(kind=dp), | intent(out) | :: | taub(*) | |||
| real(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
SGGQRF computes a generalized QR factorization of an N-by-M matrix A and an N-by-P matrix B: A = QR, B = QTZ, where Q is an N-by-N orthogonal matrix, Z is a P-by-P orthogonal matrix, and R and T assume one of the forms: if N >= M, R = ( R11 ) M , or if N < M, R = ( R11 R12 ) N, ( 0 ) N-M N M-N M where R11 is upper triangular, and if N <= P, T = ( 0 T12 ) N, or if N > P, T = ( T11 ) N-P, P-N N ( T21 ) P P where T12 or T21 is upper triangular. In particular, if B is square and nonsingular, the GQR factorization of A and B implicitly gives the QR factorization of inv(B)A: inv(B)A = ZT(inv(T)R) where inv(B) denotes the inverse of the matrix B, and Z*T denotes the transpose of the matrix Z.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | p | |||
| real(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=sp), | intent(out) | :: | taua(*) | |||
| real(kind=sp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| real(kind=sp), | intent(out) | :: | taub(*) | |||
| real(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
ZGGQRF computes a generalized QR factorization of an N-by-M matrix A and an N-by-P matrix B: A = QR, B = QTZ, where Q is an N-by-N unitary matrix, Z is a P-by-P unitary matrix, and R and T assume one of the forms: if N >= M, R = ( R11 ) M , or if N < M, R = ( R11 R12 ) N, ( 0 ) N-M N M-N M where R11 is upper triangular, and if N <= P, T = ( 0 T12 ) N, or if N > P, T = ( T11 ) N-P, P-N N ( T21 ) P P where T12 or T21 is upper triangular. In particular, if B is square and nonsingular, the GQR factorization of A and B implicitly gives the QR factorization of inv(B)A: inv(B)A = ZH * (inv(T)R) where inv(B) denotes the inverse of the matrix B, and Z**H denotes the conjugate transpose of matrix Z.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | p | |||
| complex(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=dp), | intent(out) | :: | taua(*) | |||
| complex(kind=dp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| complex(kind=dp), | intent(out) | :: | taub(*) | |||
| complex(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
GGRQF computes a generalized RQ factorization of an M-by-N matrix A and a P-by-N matrix B: A = RQ, B = ZTQ, where Q is an N-by-N unitary matrix, Z is a P-by-P unitary matrix, and R and T assume one of the forms: if M <= N, R = ( 0 R12 ) M, or if M > N, R = ( R11 ) M-N, N-M M ( R21 ) N N where R12 or R21 is upper triangular, and if P >= N, T = ( T11 ) N , or if P < N, T = ( T11 T12 ) P, ( 0 ) P-N P N-P N where T11 is upper triangular. In particular, if B is square and nonsingular, the GRQ factorization of A and B implicitly gives the RQ factorization of Ainv(B): Ainv(B) = (Rinv(T))ZH where inv(B) denotes the inverse of the matrix B, and Z*H denotes the conjugate transpose of the matrix Z.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | p | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=sp), | intent(out) | :: | taua(*) | |||
| complex(kind=sp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| complex(kind=sp), | intent(out) | :: | taub(*) | |||
| complex(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | p | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=dp), | intent(out) | :: | taua(*) | |||
| real(kind=dp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| real(kind=dp), | intent(out) | :: | taub(*) | |||
| real(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | p | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=sp), | intent(out) | :: | taua(*) | |||
| real(kind=sp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| real(kind=sp), | intent(out) | :: | taub(*) | |||
| real(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | p | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=dp), | intent(out) | :: | taua(*) | |||
| complex(kind=dp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| complex(kind=dp), | intent(out) | :: | taub(*) | |||
| complex(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
CGGRQF computes a generalized RQ factorization of an M-by-N matrix A and a P-by-N matrix B: A = RQ, B = ZTQ, where Q is an N-by-N unitary matrix, Z is a P-by-P unitary matrix, and R and T assume one of the forms: if M <= N, R = ( 0 R12 ) M, or if M > N, R = ( R11 ) M-N, N-M M ( R21 ) N N where R12 or R21 is upper triangular, and if P >= N, T = ( T11 ) N , or if P < N, T = ( T11 T12 ) P, ( 0 ) P-N P N-P N where T11 is upper triangular. In particular, if B is square and nonsingular, the GRQ factorization of A and B implicitly gives the RQ factorization of Ainv(B): Ainv(B) = (Rinv(T))ZH where inv(B) denotes the inverse of the matrix B, and Z*H denotes the conjugate transpose of the matrix Z.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | p | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=sp), | intent(out) | :: | taua(*) | |||
| complex(kind=sp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| complex(kind=sp), | intent(out) | :: | taub(*) | |||
| complex(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
DGGRQF computes a generalized RQ factorization of an M-by-N matrix A and a P-by-N matrix B: A = RQ, B = ZTQ, where Q is an N-by-N orthogonal matrix, Z is a P-by-P orthogonal matrix, and R and T assume one of the forms: if M <= N, R = ( 0 R12 ) M, or if M > N, R = ( R11 ) M-N, N-M M ( R21 ) N N where R12 or R21 is upper triangular, and if P >= N, T = ( T11 ) N , or if P < N, T = ( T11 T12 ) P, ( 0 ) P-N P N-P N where T11 is upper triangular. In particular, if B is square and nonsingular, the GRQ factorization of A and B implicitly gives the RQ factorization of Ainv(B): Ainv(B) = (Rinv(T))ZT where inv(B) denotes the inverse of the matrix B, and Z*T denotes the transpose of the matrix Z.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | p | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=dp), | intent(out) | :: | taua(*) | |||
| real(kind=dp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| real(kind=dp), | intent(out) | :: | taub(*) | |||
| real(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
SGGRQF computes a generalized RQ factorization of an M-by-N matrix A and a P-by-N matrix B: A = RQ, B = ZTQ, where Q is an N-by-N orthogonal matrix, Z is a P-by-P orthogonal matrix, and R and T assume one of the forms: if M <= N, R = ( 0 R12 ) M, or if M > N, R = ( R11 ) M-N, N-M M ( R21 ) N N where R12 or R21 is upper triangular, and if P >= N, T = ( T11 ) N , or if P < N, T = ( T11 T12 ) P, ( 0 ) P-N P N-P N where T11 is upper triangular. In particular, if B is square and nonsingular, the GRQ factorization of A and B implicitly gives the RQ factorization of Ainv(B): Ainv(B) = (Rinv(T))ZT where inv(B) denotes the inverse of the matrix B, and Z*T denotes the transpose of the matrix Z.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | p | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=sp), | intent(out) | :: | taua(*) | |||
| real(kind=sp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| real(kind=sp), | intent(out) | :: | taub(*) | |||
| real(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
ZGGRQF computes a generalized RQ factorization of an M-by-N matrix A and a P-by-N matrix B: A = RQ, B = ZTQ, where Q is an N-by-N unitary matrix, Z is a P-by-P unitary matrix, and R and T assume one of the forms: if M <= N, R = ( 0 R12 ) M, or if M > N, R = ( R11 ) M-N, N-M M ( R21 ) N N where R12 or R21 is upper triangular, and if P >= N, T = ( T11 ) N , or if P < N, T = ( T11 T12 ) P, ( 0 ) P-N P N-P N where T11 is upper triangular. In particular, if B is square and nonsingular, the GRQ factorization of A and B implicitly gives the RQ factorization of Ainv(B): Ainv(B) = (Rinv(T))ZH where inv(B) denotes the inverse of the matrix B, and Z*H denotes the conjugate transpose of the matrix Z.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | p | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=dp), | intent(out) | :: | taua(*) | |||
| complex(kind=dp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| complex(kind=dp), | intent(out) | :: | taub(*) | |||
| complex(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
GSVJ0 is called from CGESVJ as a pre-processor and that is its main purpose. It applies Jacobi rotations in the same way as CGESVJ does, but it does not check convergence (stopping criterion). Few tuning parameters (marked by [TP]) are available for the implementer.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | jobv | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=sp), | intent(inout) | :: | d(n) | |||
| real(kind=sp), | intent(inout) | :: | sva(n) | |||
| integer(kind=ilp), | intent(in) | :: | mv | |||
| complex(kind=sp), | intent(inout) | :: | v(ldv,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldv | |||
| real(kind=sp), | intent(in) | :: | eps | |||
| real(kind=sp), | intent(in) | :: | sfmin | |||
| real(kind=sp), | intent(in) | :: | tol | |||
| integer(kind=ilp), | intent(in) | :: | nsweep | |||
| complex(kind=sp), | intent(out) | :: | work(lwork) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | jobv | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=dp), | intent(inout) | :: | d(n) | |||
| real(kind=dp), | intent(inout) | :: | sva(n) | |||
| integer(kind=ilp), | intent(in) | :: | mv | |||
| real(kind=dp), | intent(inout) | :: | v(ldv,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldv | |||
| real(kind=dp), | intent(in) | :: | eps | |||
| real(kind=dp), | intent(in) | :: | sfmin | |||
| real(kind=dp), | intent(in) | :: | tol | |||
| integer(kind=ilp), | intent(in) | :: | nsweep | |||
| real(kind=dp), | intent(out) | :: | work(lwork) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | jobv | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=sp), | intent(inout) | :: | d(n) | |||
| real(kind=sp), | intent(inout) | :: | sva(n) | |||
| integer(kind=ilp), | intent(in) | :: | mv | |||
| real(kind=sp), | intent(inout) | :: | v(ldv,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldv | |||
| real(kind=sp), | intent(in) | :: | eps | |||
| real(kind=sp), | intent(in) | :: | sfmin | |||
| real(kind=sp), | intent(in) | :: | tol | |||
| integer(kind=ilp), | intent(in) | :: | nsweep | |||
| real(kind=sp), | intent(out) | :: | work(lwork) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | jobv | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=dp), | intent(inout) | :: | d(n) | |||
| real(kind=dp), | intent(inout) | :: | sva(n) | |||
| integer(kind=ilp), | intent(in) | :: | mv | |||
| complex(kind=dp), | intent(inout) | :: | v(ldv,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldv | |||
| real(kind=dp), | intent(in) | :: | eps | |||
| real(kind=dp), | intent(in) | :: | sfmin | |||
| real(kind=dp), | intent(in) | :: | tol | |||
| integer(kind=ilp), | intent(in) | :: | nsweep | |||
| complex(kind=dp), | intent(out) | :: | work(lwork) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
CGSVJ0 is called from CGESVJ as a pre-processor and that is its main purpose. It applies Jacobi rotations in the same way as CGESVJ does, but it does not check convergence (stopping criterion). Few tuning parameters (marked by [TP]) are available for the implementer.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | jobv | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=sp), | intent(inout) | :: | d(n) | |||
| real(kind=sp), | intent(inout) | :: | sva(n) | |||
| integer(kind=ilp), | intent(in) | :: | mv | |||
| complex(kind=sp), | intent(inout) | :: | v(ldv,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldv | |||
| real(kind=sp), | intent(in) | :: | eps | |||
| real(kind=sp), | intent(in) | :: | sfmin | |||
| real(kind=sp), | intent(in) | :: | tol | |||
| integer(kind=ilp), | intent(in) | :: | nsweep | |||
| complex(kind=sp), | intent(out) | :: | work(lwork) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
DGSVJ0 is called from DGESVJ as a pre-processor and that is its main purpose. It applies Jacobi rotations in the same way as DGESVJ does, but it does not check convergence (stopping criterion). Few tuning parameters (marked by [TP]) are available for the implementer.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | jobv | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=dp), | intent(inout) | :: | d(n) | |||
| real(kind=dp), | intent(inout) | :: | sva(n) | |||
| integer(kind=ilp), | intent(in) | :: | mv | |||
| real(kind=dp), | intent(inout) | :: | v(ldv,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldv | |||
| real(kind=dp), | intent(in) | :: | eps | |||
| real(kind=dp), | intent(in) | :: | sfmin | |||
| real(kind=dp), | intent(in) | :: | tol | |||
| integer(kind=ilp), | intent(in) | :: | nsweep | |||
| real(kind=dp), | intent(out) | :: | work(lwork) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
SGSVJ0 is called from SGESVJ as a pre-processor and that is its main purpose. It applies Jacobi rotations in the same way as SGESVJ does, but it does not check convergence (stopping criterion). Few tuning parameters (marked by [TP]) are available for the implementer.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | jobv | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=sp), | intent(inout) | :: | d(n) | |||
| real(kind=sp), | intent(inout) | :: | sva(n) | |||
| integer(kind=ilp), | intent(in) | :: | mv | |||
| real(kind=sp), | intent(inout) | :: | v(ldv,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldv | |||
| real(kind=sp), | intent(in) | :: | eps | |||
| real(kind=sp), | intent(in) | :: | sfmin | |||
| real(kind=sp), | intent(in) | :: | tol | |||
| integer(kind=ilp), | intent(in) | :: | nsweep | |||
| real(kind=sp), | intent(out) | :: | work(lwork) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
ZGSVJ0 is called from ZGESVJ as a pre-processor and that is its main purpose. It applies Jacobi rotations in the same way as ZGESVJ does, but it does not check convergence (stopping criterion). Few tuning parameters (marked by [TP]) are available for the implementer.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | jobv | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=dp), | intent(inout) | :: | d(n) | |||
| real(kind=dp), | intent(inout) | :: | sva(n) | |||
| integer(kind=ilp), | intent(in) | :: | mv | |||
| complex(kind=dp), | intent(inout) | :: | v(ldv,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldv | |||
| real(kind=dp), | intent(in) | :: | eps | |||
| real(kind=dp), | intent(in) | :: | sfmin | |||
| real(kind=dp), | intent(in) | :: | tol | |||
| integer(kind=ilp), | intent(in) | :: | nsweep | |||
| complex(kind=dp), | intent(out) | :: | work(lwork) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
GSVJ1 is called from CGESVJ as a pre-processor and that is its main purpose. It applies Jacobi rotations in the same way as CGESVJ does, but it targets only particular pivots and it does not check convergence (stopping criterion). Few tuning parameters (marked by [TP]) are available for the implementer. Further Details ~~~~~~~~~~~~~~~ GSVJ1 applies few sweeps of Jacobi rotations in the column space of the input M-by-N matrix A. The pivot pairs are taken from the (1,2) off-diagonal block in the corresponding N-by-N Gram matrix A^T * A. The block-entries (tiles) of the (1,2) off-diagonal block are marked by the [x]'s in the following scheme: | * * * [x] [x] [x]| | * * * [x] [x] [x]| Row-cycling in the nblr-by-nblc [x] blocks. | * * * [x] [x] [x]| Row-cyclic pivoting inside each [x] block. |[x] [x] [x] * * * | |[x] [x] [x] * * * | |[x] [x] [x] * * * | In terms of the columns of A, the first N1 columns are rotated 'against' the remaining N-N1 columns, trying to increase the angle between the corresponding subspaces. The off-diagonal block is N1-by(N-N1) and it is tiled using quadratic tiles of side KBL. Here, KBL is a tuning parameter. The number of sweeps is given in NSWEEP and the orthogonality threshold is given in TOL.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | jobv | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | n1 | |||
| complex(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=sp), | intent(inout) | :: | d(n) | |||
| real(kind=sp), | intent(inout) | :: | sva(n) | |||
| integer(kind=ilp), | intent(in) | :: | mv | |||
| complex(kind=sp), | intent(inout) | :: | v(ldv,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldv | |||
| real(kind=sp), | intent(in) | :: | eps | |||
| real(kind=sp), | intent(in) | :: | sfmin | |||
| real(kind=sp), | intent(in) | :: | tol | |||
| integer(kind=ilp), | intent(in) | :: | nsweep | |||
| complex(kind=sp), | intent(out) | :: | work(lwork) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | jobv | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | n1 | |||
| real(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=dp), | intent(inout) | :: | d(n) | |||
| real(kind=dp), | intent(inout) | :: | sva(n) | |||
| integer(kind=ilp), | intent(in) | :: | mv | |||
| real(kind=dp), | intent(inout) | :: | v(ldv,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldv | |||
| real(kind=dp), | intent(in) | :: | eps | |||
| real(kind=dp), | intent(in) | :: | sfmin | |||
| real(kind=dp), | intent(in) | :: | tol | |||
| integer(kind=ilp), | intent(in) | :: | nsweep | |||
| real(kind=dp), | intent(out) | :: | work(lwork) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | jobv | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | n1 | |||
| real(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=sp), | intent(inout) | :: | d(n) | |||
| real(kind=sp), | intent(inout) | :: | sva(n) | |||
| integer(kind=ilp), | intent(in) | :: | mv | |||
| real(kind=sp), | intent(inout) | :: | v(ldv,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldv | |||
| real(kind=sp), | intent(in) | :: | eps | |||
| real(kind=sp), | intent(in) | :: | sfmin | |||
| real(kind=sp), | intent(in) | :: | tol | |||
| integer(kind=ilp), | intent(in) | :: | nsweep | |||
| real(kind=sp), | intent(out) | :: | work(lwork) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | jobv | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | n1 | |||
| complex(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=dp), | intent(inout) | :: | d(n) | |||
| real(kind=dp), | intent(inout) | :: | sva(n) | |||
| integer(kind=ilp), | intent(in) | :: | mv | |||
| complex(kind=dp), | intent(inout) | :: | v(ldv,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldv | |||
| real(kind=dp), | intent(in) | :: | eps | |||
| real(kind=dp), | intent(in) | :: | sfmin | |||
| real(kind=dp), | intent(in) | :: | tol | |||
| integer(kind=ilp), | intent(in) | :: | nsweep | |||
| complex(kind=dp), | intent(out) | :: | work(lwork) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
CGSVJ1 is called from CGESVJ as a pre-processor and that is its main purpose. It applies Jacobi rotations in the same way as CGESVJ does, but it targets only particular pivots and it does not check convergence (stopping criterion). Few tuning parameters (marked by [TP]) are available for the implementer. Further Details ~~~~~~~~~~~~~~~ CGSVJ1 applies few sweeps of Jacobi rotations in the column space of the input M-by-N matrix A. The pivot pairs are taken from the (1,2) off-diagonal block in the corresponding N-by-N Gram matrix A^T * A. The block-entries (tiles) of the (1,2) off-diagonal block are marked by the [x]'s in the following scheme: | * * * [x] [x] [x]| | * * * [x] [x] [x]| Row-cycling in the nblr-by-nblc [x] blocks. | * * * [x] [x] [x]| Row-cyclic pivoting inside each [x] block. |[x] [x] [x] * * * | |[x] [x] [x] * * * | |[x] [x] [x] * * * | In terms of the columns of A, the first N1 columns are rotated 'against' the remaining N-N1 columns, trying to increase the angle between the corresponding subspaces. The off-diagonal block is N1-by(N-N1) and it is tiled using quadratic tiles of side KBL. Here, KBL is a tuning parameter. The number of sweeps is given in NSWEEP and the orthogonality threshold is given in TOL.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | jobv | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | n1 | |||
| complex(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=sp), | intent(inout) | :: | d(n) | |||
| real(kind=sp), | intent(inout) | :: | sva(n) | |||
| integer(kind=ilp), | intent(in) | :: | mv | |||
| complex(kind=sp), | intent(inout) | :: | v(ldv,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldv | |||
| real(kind=sp), | intent(in) | :: | eps | |||
| real(kind=sp), | intent(in) | :: | sfmin | |||
| real(kind=sp), | intent(in) | :: | tol | |||
| integer(kind=ilp), | intent(in) | :: | nsweep | |||
| complex(kind=sp), | intent(out) | :: | work(lwork) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
DGSVJ1 is called from DGESVJ as a pre-processor and that is its main purpose. It applies Jacobi rotations in the same way as DGESVJ does, but it targets only particular pivots and it does not check convergence (stopping criterion). Few tuning parameters (marked by [TP]) are available for the implementer. Further Details ~~~~~~~~~~~~~~~ DGSVJ1 applies few sweeps of Jacobi rotations in the column space of the input M-by-N matrix A. The pivot pairs are taken from the (1,2) off-diagonal block in the corresponding N-by-N Gram matrix A^T * A. The block-entries (tiles) of the (1,2) off-diagonal block are marked by the [x]'s in the following scheme: | * * * [x] [x] [x]| | * * * [x] [x] [x]| Row-cycling in the nblr-by-nblc [x] blocks. | * * * [x] [x] [x]| Row-cyclic pivoting inside each [x] block. |[x] [x] [x] * * * | |[x] [x] [x] * * * | |[x] [x] [x] * * * | In terms of the columns of A, the first N1 columns are rotated 'against' the remaining N-N1 columns, trying to increase the angle between the corresponding subspaces. The off-diagonal block is N1-by(N-N1) and it is tiled using quadratic tiles of side KBL. Here, KBL is a tuning parameter. The number of sweeps is given in NSWEEP and the orthogonality threshold is given in TOL.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | jobv | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | n1 | |||
| real(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=dp), | intent(inout) | :: | d(n) | |||
| real(kind=dp), | intent(inout) | :: | sva(n) | |||
| integer(kind=ilp), | intent(in) | :: | mv | |||
| real(kind=dp), | intent(inout) | :: | v(ldv,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldv | |||
| real(kind=dp), | intent(in) | :: | eps | |||
| real(kind=dp), | intent(in) | :: | sfmin | |||
| real(kind=dp), | intent(in) | :: | tol | |||
| integer(kind=ilp), | intent(in) | :: | nsweep | |||
| real(kind=dp), | intent(out) | :: | work(lwork) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
SGSVJ1 is called from SGESVJ as a pre-processor and that is its main purpose. It applies Jacobi rotations in the same way as SGESVJ does, but it targets only particular pivots and it does not check convergence (stopping criterion). Few tuning parameters (marked by [TP]) are available for the implementer. Further Details ~~~~~~~~~~~~~~~ SGSVJ1 applies few sweeps of Jacobi rotations in the column space of the input M-by-N matrix A. The pivot pairs are taken from the (1,2) off-diagonal block in the corresponding N-by-N Gram matrix A^T * A. The block-entries (tiles) of the (1,2) off-diagonal block are marked by the [x]'s in the following scheme: | * * * [x] [x] [x]| | * * * [x] [x] [x]| Row-cycling in the nblr-by-nblc [x] blocks. | * * * [x] [x] [x]| Row-cyclic pivoting inside each [x] block. |[x] [x] [x] * * * | |[x] [x] [x] * * * | |[x] [x] [x] * * * | In terms of the columns of A, the first N1 columns are rotated 'against' the remaining N-N1 columns, trying to increase the angle between the corresponding subspaces. The off-diagonal block is N1-by(N-N1) and it is tiled using quadratic tiles of side KBL. Here, KBL is a tuning parameter. The number of sweeps is given in NSWEEP and the orthogonality threshold is given in TOL.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | jobv | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | n1 | |||
| real(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=sp), | intent(inout) | :: | d(n) | |||
| real(kind=sp), | intent(inout) | :: | sva(n) | |||
| integer(kind=ilp), | intent(in) | :: | mv | |||
| real(kind=sp), | intent(inout) | :: | v(ldv,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldv | |||
| real(kind=sp), | intent(in) | :: | eps | |||
| real(kind=sp), | intent(in) | :: | sfmin | |||
| real(kind=sp), | intent(in) | :: | tol | |||
| integer(kind=ilp), | intent(in) | :: | nsweep | |||
| real(kind=sp), | intent(out) | :: | work(lwork) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
ZGSVJ1 is called from ZGESVJ as a pre-processor and that is its main purpose. It applies Jacobi rotations in the same way as ZGESVJ does, but it targets only particular pivots and it does not check convergence (stopping criterion). Few tuning parameters (marked by [TP]) are available for the implementer. Further Details ~~~~~~~~~~~~~~~ ZGSVJ1 applies few sweeps of Jacobi rotations in the column space of the input M-by-N matrix A. The pivot pairs are taken from the (1,2) off-diagonal block in the corresponding N-by-N Gram matrix A^T * A. The block-entries (tiles) of the (1,2) off-diagonal block are marked by the [x]'s in the following scheme: | * * * [x] [x] [x]| | * * * [x] [x] [x]| Row-cycling in the nblr-by-nblc [x] blocks. | * * * [x] [x] [x]| Row-cyclic pivoting inside each [x] block. |[x] [x] [x] * * * | |[x] [x] [x] * * * | |[x] [x] [x] * * * | In terms of the columns of A, the first N1 columns are rotated 'against' the remaining N-N1 columns, trying to increase the angle between the corresponding subspaces. The off-diagonal block is N1-by(N-N1) and it is tiled using quadratic tiles of side KBL. Here, KBL is a tuning parameter. The number of sweeps is given in NSWEEP and the orthogonality threshold is given in TOL.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | jobv | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | n1 | |||
| complex(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=dp), | intent(inout) | :: | d(n) | |||
| real(kind=dp), | intent(inout) | :: | sva(n) | |||
| integer(kind=ilp), | intent(in) | :: | mv | |||
| complex(kind=dp), | intent(inout) | :: | v(ldv,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldv | |||
| real(kind=dp), | intent(in) | :: | eps | |||
| real(kind=dp), | intent(in) | :: | sfmin | |||
| real(kind=dp), | intent(in) | :: | tol | |||
| integer(kind=ilp), | intent(in) | :: | nsweep | |||
| complex(kind=dp), | intent(out) | :: | work(lwork) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
GTCON estimates the reciprocal of the condition number of a complex tridiagonal matrix A using the LU factorization as computed by CGTTRF. An estimate is obtained for norm(inv(A)), and the reciprocal of the condition number is computed as RCOND = 1 / (ANORM * norm(inv(A))).
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | norm | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=sp), | intent(in) | :: | dl(*) | |||
| complex(kind=sp), | intent(in) | :: | d(*) | |||
| complex(kind=sp), | intent(in) | :: | du(*) | |||
| complex(kind=sp), | intent(in) | :: | du2(*) | |||
| integer(kind=ilp), | intent(in) | :: | ipiv(*) | |||
| real(kind=sp), | intent(in) | :: | anorm | |||
| real(kind=sp), | intent(out) | :: | rcond | |||
| complex(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | norm | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=dp), | intent(in) | :: | dl(*) | |||
| real(kind=dp), | intent(in) | :: | d(*) | |||
| real(kind=dp), | intent(in) | :: | du(*) | |||
| real(kind=dp), | intent(in) | :: | du2(*) | |||
| integer(kind=ilp), | intent(in) | :: | ipiv(*) | |||
| real(kind=dp), | intent(in) | :: | anorm | |||
| real(kind=dp), | intent(out) | :: | rcond | |||
| real(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | iwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | norm | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=sp), | intent(in) | :: | dl(*) | |||
| real(kind=sp), | intent(in) | :: | d(*) | |||
| real(kind=sp), | intent(in) | :: | du(*) | |||
| real(kind=sp), | intent(in) | :: | du2(*) | |||
| integer(kind=ilp), | intent(in) | :: | ipiv(*) | |||
| real(kind=sp), | intent(in) | :: | anorm | |||
| real(kind=sp), | intent(out) | :: | rcond | |||
| real(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | iwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | norm | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=dp), | intent(in) | :: | dl(*) | |||
| complex(kind=dp), | intent(in) | :: | d(*) | |||
| complex(kind=dp), | intent(in) | :: | du(*) | |||
| complex(kind=dp), | intent(in) | :: | du2(*) | |||
| integer(kind=ilp), | intent(in) | :: | ipiv(*) | |||
| real(kind=dp), | intent(in) | :: | anorm | |||
| real(kind=dp), | intent(out) | :: | rcond | |||
| complex(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
CGTCON estimates the reciprocal of the condition number of a complex tridiagonal matrix A using the LU factorization as computed by CGTTRF. An estimate is obtained for norm(inv(A)), and the reciprocal of the condition number is computed as RCOND = 1 / (ANORM * norm(inv(A))).
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | norm | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=sp), | intent(in) | :: | dl(*) | |||
| complex(kind=sp), | intent(in) | :: | d(*) | |||
| complex(kind=sp), | intent(in) | :: | du(*) | |||
| complex(kind=sp), | intent(in) | :: | du2(*) | |||
| integer(kind=ilp), | intent(in) | :: | ipiv(*) | |||
| real(kind=sp), | intent(in) | :: | anorm | |||
| real(kind=sp), | intent(out) | :: | rcond | |||
| complex(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
DGTCON estimates the reciprocal of the condition number of a real tridiagonal matrix A using the LU factorization as computed by DGTTRF. An estimate is obtained for norm(inv(A)), and the reciprocal of the condition number is computed as RCOND = 1 / (ANORM * norm(inv(A))).
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | norm | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=dp), | intent(in) | :: | dl(*) | |||
| real(kind=dp), | intent(in) | :: | d(*) | |||
| real(kind=dp), | intent(in) | :: | du(*) | |||
| real(kind=dp), | intent(in) | :: | du2(*) | |||
| integer(kind=ilp), | intent(in) | :: | ipiv(*) | |||
| real(kind=dp), | intent(in) | :: | anorm | |||
| real(kind=dp), | intent(out) | :: | rcond | |||
| real(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | iwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
SGTCON estimates the reciprocal of the condition number of a real tridiagonal matrix A using the LU factorization as computed by SGTTRF. An estimate is obtained for norm(inv(A)), and the reciprocal of the condition number is computed as RCOND = 1 / (ANORM * norm(inv(A))).
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | norm | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=sp), | intent(in) | :: | dl(*) | |||
| real(kind=sp), | intent(in) | :: | d(*) | |||
| real(kind=sp), | intent(in) | :: | du(*) | |||
| real(kind=sp), | intent(in) | :: | du2(*) | |||
| integer(kind=ilp), | intent(in) | :: | ipiv(*) | |||
| real(kind=sp), | intent(in) | :: | anorm | |||
| real(kind=sp), | intent(out) | :: | rcond | |||
| real(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | iwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
ZGTCON estimates the reciprocal of the condition number of a complex tridiagonal matrix A using the LU factorization as computed by ZGTTRF. An estimate is obtained for norm(inv(A)), and the reciprocal of the condition number is computed as RCOND = 1 / (ANORM * norm(inv(A))).
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | norm | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=dp), | intent(in) | :: | dl(*) | |||
| complex(kind=dp), | intent(in) | :: | d(*) | |||
| complex(kind=dp), | intent(in) | :: | du(*) | |||
| complex(kind=dp), | intent(in) | :: | du2(*) | |||
| integer(kind=ilp), | intent(in) | :: | ipiv(*) | |||
| real(kind=dp), | intent(in) | :: | anorm | |||
| real(kind=dp), | intent(out) | :: | rcond | |||
| complex(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
GTRFS improves the computed solution to a system of linear equations when the coefficient matrix is tridiagonal, and provides error bounds and backward error estimates for the solution.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | trans | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| complex(kind=sp), | intent(in) | :: | dl(*) | |||
| complex(kind=sp), | intent(in) | :: | d(*) | |||
| complex(kind=sp), | intent(in) | :: | du(*) | |||
| complex(kind=sp), | intent(in) | :: | dlf(*) | |||
| complex(kind=sp), | intent(in) | :: | df(*) | |||
| complex(kind=sp), | intent(in) | :: | duf(*) | |||
| complex(kind=sp), | intent(in) | :: | du2(*) | |||
| integer(kind=ilp), | intent(in) | :: | ipiv(*) | |||
| complex(kind=sp), | intent(in) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| complex(kind=sp), | intent(inout) | :: | x(ldx,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldx | |||
| real(kind=sp), | intent(out) | :: | ferr(*) | |||
| real(kind=sp), | intent(out) | :: | berr(*) | |||
| complex(kind=sp), | intent(out) | :: | work(*) | |||
| real(kind=sp), | intent(out) | :: | rwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | trans | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| real(kind=dp), | intent(in) | :: | dl(*) | |||
| real(kind=dp), | intent(in) | :: | d(*) | |||
| real(kind=dp), | intent(in) | :: | du(*) | |||
| real(kind=dp), | intent(in) | :: | dlf(*) | |||
| real(kind=dp), | intent(in) | :: | df(*) | |||
| real(kind=dp), | intent(in) | :: | duf(*) | |||
| real(kind=dp), | intent(in) | :: | du2(*) | |||
| integer(kind=ilp), | intent(in) | :: | ipiv(*) | |||
| real(kind=dp), | intent(in) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| real(kind=dp), | intent(inout) | :: | x(ldx,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldx | |||
| real(kind=dp), | intent(out) | :: | ferr(*) | |||
| real(kind=dp), | intent(out) | :: | berr(*) | |||
| real(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | iwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | trans | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| real(kind=sp), | intent(in) | :: | dl(*) | |||
| real(kind=sp), | intent(in) | :: | d(*) | |||
| real(kind=sp), | intent(in) | :: | du(*) | |||
| real(kind=sp), | intent(in) | :: | dlf(*) | |||
| real(kind=sp), | intent(in) | :: | df(*) | |||
| real(kind=sp), | intent(in) | :: | duf(*) | |||
| real(kind=sp), | intent(in) | :: | du2(*) | |||
| integer(kind=ilp), | intent(in) | :: | ipiv(*) | |||
| real(kind=sp), | intent(in) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| real(kind=sp), | intent(inout) | :: | x(ldx,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldx | |||
| real(kind=sp), | intent(out) | :: | ferr(*) | |||
| real(kind=sp), | intent(out) | :: | berr(*) | |||
| real(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | iwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | trans | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| complex(kind=dp), | intent(in) | :: | dl(*) | |||
| complex(kind=dp), | intent(in) | :: | d(*) | |||
| complex(kind=dp), | intent(in) | :: | du(*) | |||
| complex(kind=dp), | intent(in) | :: | dlf(*) | |||
| complex(kind=dp), | intent(in) | :: | df(*) | |||
| complex(kind=dp), | intent(in) | :: | duf(*) | |||
| complex(kind=dp), | intent(in) | :: | du2(*) | |||
| integer(kind=ilp), | intent(in) | :: | ipiv(*) | |||
| complex(kind=dp), | intent(in) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| complex(kind=dp), | intent(inout) | :: | x(ldx,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldx | |||
| real(kind=dp), | intent(out) | :: | ferr(*) | |||
| real(kind=dp), | intent(out) | :: | berr(*) | |||
| complex(kind=dp), | intent(out) | :: | work(*) | |||
| real(kind=dp), | intent(out) | :: | rwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
CGTRFS improves the computed solution to a system of linear equations when the coefficient matrix is tridiagonal, and provides error bounds and backward error estimates for the solution.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | trans | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| complex(kind=sp), | intent(in) | :: | dl(*) | |||
| complex(kind=sp), | intent(in) | :: | d(*) | |||
| complex(kind=sp), | intent(in) | :: | du(*) | |||
| complex(kind=sp), | intent(in) | :: | dlf(*) | |||
| complex(kind=sp), | intent(in) | :: | df(*) | |||
| complex(kind=sp), | intent(in) | :: | duf(*) | |||
| complex(kind=sp), | intent(in) | :: | du2(*) | |||
| integer(kind=ilp), | intent(in) | :: | ipiv(*) | |||
| complex(kind=sp), | intent(in) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| complex(kind=sp), | intent(inout) | :: | x(ldx,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldx | |||
| real(kind=sp), | intent(out) | :: | ferr(*) | |||
| real(kind=sp), | intent(out) | :: | berr(*) | |||
| complex(kind=sp), | intent(out) | :: | work(*) | |||
| real(kind=sp), | intent(out) | :: | rwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
DGTRFS improves the computed solution to a system of linear equations when the coefficient matrix is tridiagonal, and provides error bounds and backward error estimates for the solution.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | trans | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| real(kind=dp), | intent(in) | :: | dl(*) | |||
| real(kind=dp), | intent(in) | :: | d(*) | |||
| real(kind=dp), | intent(in) | :: | du(*) | |||
| real(kind=dp), | intent(in) | :: | dlf(*) | |||
| real(kind=dp), | intent(in) | :: | df(*) | |||
| real(kind=dp), | intent(in) | :: | duf(*) | |||
| real(kind=dp), | intent(in) | :: | du2(*) | |||
| integer(kind=ilp), | intent(in) | :: | ipiv(*) | |||
| real(kind=dp), | intent(in) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| real(kind=dp), | intent(inout) | :: | x(ldx,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldx | |||
| real(kind=dp), | intent(out) | :: | ferr(*) | |||
| real(kind=dp), | intent(out) | :: | berr(*) | |||
| real(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | iwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
SGTRFS improves the computed solution to a system of linear equations when the coefficient matrix is tridiagonal, and provides error bounds and backward error estimates for the solution.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | trans | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| real(kind=sp), | intent(in) | :: | dl(*) | |||
| real(kind=sp), | intent(in) | :: | d(*) | |||
| real(kind=sp), | intent(in) | :: | du(*) | |||
| real(kind=sp), | intent(in) | :: | dlf(*) | |||
| real(kind=sp), | intent(in) | :: | df(*) | |||
| real(kind=sp), | intent(in) | :: | duf(*) | |||
| real(kind=sp), | intent(in) | :: | du2(*) | |||
| integer(kind=ilp), | intent(in) | :: | ipiv(*) | |||
| real(kind=sp), | intent(in) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| real(kind=sp), | intent(inout) | :: | x(ldx,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldx | |||
| real(kind=sp), | intent(out) | :: | ferr(*) | |||
| real(kind=sp), | intent(out) | :: | berr(*) | |||
| real(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | iwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
ZGTRFS improves the computed solution to a system of linear equations when the coefficient matrix is tridiagonal, and provides error bounds and backward error estimates for the solution.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | trans | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| complex(kind=dp), | intent(in) | :: | dl(*) | |||
| complex(kind=dp), | intent(in) | :: | d(*) | |||
| complex(kind=dp), | intent(in) | :: | du(*) | |||
| complex(kind=dp), | intent(in) | :: | dlf(*) | |||
| complex(kind=dp), | intent(in) | :: | df(*) | |||
| complex(kind=dp), | intent(in) | :: | duf(*) | |||
| complex(kind=dp), | intent(in) | :: | du2(*) | |||
| integer(kind=ilp), | intent(in) | :: | ipiv(*) | |||
| complex(kind=dp), | intent(in) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| complex(kind=dp), | intent(inout) | :: | x(ldx,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldx | |||
| real(kind=dp), | intent(out) | :: | ferr(*) | |||
| real(kind=dp), | intent(out) | :: | berr(*) | |||
| complex(kind=dp), | intent(out) | :: | work(*) | |||
| real(kind=dp), | intent(out) | :: | rwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
GTSV solves the equation AX = B, where A is an N-by-N tridiagonal matrix, by Gaussian elimination with partial pivoting. Note that the equation AT X = B may be solved by interchanging the order of the arguments DU and DL.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| complex(kind=sp), | intent(inout) | :: | dl(*) | |||
| complex(kind=sp), | intent(inout) | :: | d(*) | |||
| complex(kind=sp), | intent(inout) | :: | du(*) | |||
| complex(kind=sp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| real(kind=dp), | intent(inout) | :: | dl(*) | |||
| real(kind=dp), | intent(inout) | :: | d(*) | |||
| real(kind=dp), | intent(inout) | :: | du(*) | |||
| real(kind=dp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| real(kind=sp), | intent(inout) | :: | dl(*) | |||
| real(kind=sp), | intent(inout) | :: | d(*) | |||
| real(kind=sp), | intent(inout) | :: | du(*) | |||
| real(kind=sp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| complex(kind=dp), | intent(inout) | :: | dl(*) | |||
| complex(kind=dp), | intent(inout) | :: | d(*) | |||
| complex(kind=dp), | intent(inout) | :: | du(*) | |||
| complex(kind=dp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| integer(kind=ilp), | intent(out) | :: | info |
CGTSV solves the equation AX = B, where A is an N-by-N tridiagonal matrix, by Gaussian elimination with partial pivoting. Note that the equation AT X = B may be solved by interchanging the order of the arguments DU and DL.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| complex(kind=sp), | intent(inout) | :: | dl(*) | |||
| complex(kind=sp), | intent(inout) | :: | d(*) | |||
| complex(kind=sp), | intent(inout) | :: | du(*) | |||
| complex(kind=sp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| integer(kind=ilp), | intent(out) | :: | info |
DGTSV solves the equation AX = B, where A is an n by n tridiagonal matrix, by Gaussian elimination with partial pivoting. Note that the equation ATX = B may be solved by interchanging the order of the arguments DU and DL.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| real(kind=dp), | intent(inout) | :: | dl(*) | |||
| real(kind=dp), | intent(inout) | :: | d(*) | |||
| real(kind=dp), | intent(inout) | :: | du(*) | |||
| real(kind=dp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| integer(kind=ilp), | intent(out) | :: | info |
SGTSV solves the equation AX = B, where A is an n by n tridiagonal matrix, by Gaussian elimination with partial pivoting. Note that the equation ATX = B may be solved by interchanging the order of the arguments DU and DL.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| real(kind=sp), | intent(inout) | :: | dl(*) | |||
| real(kind=sp), | intent(inout) | :: | d(*) | |||
| real(kind=sp), | intent(inout) | :: | du(*) | |||
| real(kind=sp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| integer(kind=ilp), | intent(out) | :: | info |
ZGTSV solves the equation AX = B, where A is an N-by-N tridiagonal matrix, by Gaussian elimination with partial pivoting. Note that the equation AT X = B may be solved by interchanging the order of the arguments DU and DL.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| complex(kind=dp), | intent(inout) | :: | dl(*) | |||
| complex(kind=dp), | intent(inout) | :: | d(*) | |||
| complex(kind=dp), | intent(inout) | :: | du(*) | |||
| complex(kind=dp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| integer(kind=ilp), | intent(out) | :: | info |
GTTRF computes an LU factorization of a complex tridiagonal matrix A using elimination with partial pivoting and row interchanges. The factorization has the form A = L * U where L is a product of permutation and unit lower bidiagonal matrices and U is upper triangular with nonzeros in only the main diagonal and first two superdiagonals.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=sp), | intent(inout) | :: | dl(*) | |||
| complex(kind=sp), | intent(inout) | :: | d(*) | |||
| complex(kind=sp), | intent(inout) | :: | du(*) | |||
| complex(kind=sp), | intent(out) | :: | du2(*) | |||
| integer(kind=ilp), | intent(out) | :: | ipiv(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=dp), | intent(inout) | :: | dl(*) | |||
| real(kind=dp), | intent(inout) | :: | d(*) | |||
| real(kind=dp), | intent(inout) | :: | du(*) | |||
| real(kind=dp), | intent(out) | :: | du2(*) | |||
| integer(kind=ilp), | intent(out) | :: | ipiv(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=sp), | intent(inout) | :: | dl(*) | |||
| real(kind=sp), | intent(inout) | :: | d(*) | |||
| real(kind=sp), | intent(inout) | :: | du(*) | |||
| real(kind=sp), | intent(out) | :: | du2(*) | |||
| integer(kind=ilp), | intent(out) | :: | ipiv(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=dp), | intent(inout) | :: | dl(*) | |||
| complex(kind=dp), | intent(inout) | :: | d(*) | |||
| complex(kind=dp), | intent(inout) | :: | du(*) | |||
| complex(kind=dp), | intent(out) | :: | du2(*) | |||
| integer(kind=ilp), | intent(out) | :: | ipiv(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
CGTTRF computes an LU factorization of a complex tridiagonal matrix A using elimination with partial pivoting and row interchanges. The factorization has the form A = L * U where L is a product of permutation and unit lower bidiagonal matrices and U is upper triangular with nonzeros in only the main diagonal and first two superdiagonals.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=sp), | intent(inout) | :: | dl(*) | |||
| complex(kind=sp), | intent(inout) | :: | d(*) | |||
| complex(kind=sp), | intent(inout) | :: | du(*) | |||
| complex(kind=sp), | intent(out) | :: | du2(*) | |||
| integer(kind=ilp), | intent(out) | :: | ipiv(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
DGTTRF computes an LU factorization of a real tridiagonal matrix A using elimination with partial pivoting and row interchanges. The factorization has the form A = L * U where L is a product of permutation and unit lower bidiagonal matrices and U is upper triangular with nonzeros in only the main diagonal and first two superdiagonals.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=dp), | intent(inout) | :: | dl(*) | |||
| real(kind=dp), | intent(inout) | :: | d(*) | |||
| real(kind=dp), | intent(inout) | :: | du(*) | |||
| real(kind=dp), | intent(out) | :: | du2(*) | |||
| integer(kind=ilp), | intent(out) | :: | ipiv(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
SGTTRF computes an LU factorization of a real tridiagonal matrix A using elimination with partial pivoting and row interchanges. The factorization has the form A = L * U where L is a product of permutation and unit lower bidiagonal matrices and U is upper triangular with nonzeros in only the main diagonal and first two superdiagonals.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=sp), | intent(inout) | :: | dl(*) | |||
| real(kind=sp), | intent(inout) | :: | d(*) | |||
| real(kind=sp), | intent(inout) | :: | du(*) | |||
| real(kind=sp), | intent(out) | :: | du2(*) | |||
| integer(kind=ilp), | intent(out) | :: | ipiv(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
ZGTTRF computes an LU factorization of a complex tridiagonal matrix A using elimination with partial pivoting and row interchanges. The factorization has the form A = L * U where L is a product of permutation and unit lower bidiagonal matrices and U is upper triangular with nonzeros in only the main diagonal and first two superdiagonals.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=dp), | intent(inout) | :: | dl(*) | |||
| complex(kind=dp), | intent(inout) | :: | d(*) | |||
| complex(kind=dp), | intent(inout) | :: | du(*) | |||
| complex(kind=dp), | intent(out) | :: | du2(*) | |||
| integer(kind=ilp), | intent(out) | :: | ipiv(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
GTTRS solves one of the systems of equations A * X = B, AT * X = B, or AH * X = B, with a tridiagonal matrix A using the LU factorization computed by CGTTRF.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | trans | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| complex(kind=sp), | intent(in) | :: | dl(*) | |||
| complex(kind=sp), | intent(in) | :: | d(*) | |||
| complex(kind=sp), | intent(in) | :: | du(*) | |||
| complex(kind=sp), | intent(in) | :: | du2(*) | |||
| integer(kind=ilp), | intent(in) | :: | ipiv(*) | |||
| complex(kind=sp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | trans | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| real(kind=dp), | intent(in) | :: | dl(*) | |||
| real(kind=dp), | intent(in) | :: | d(*) | |||
| real(kind=dp), | intent(in) | :: | du(*) | |||
| real(kind=dp), | intent(in) | :: | du2(*) | |||
| integer(kind=ilp), | intent(in) | :: | ipiv(*) | |||
| real(kind=dp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | trans | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| real(kind=sp), | intent(in) | :: | dl(*) | |||
| real(kind=sp), | intent(in) | :: | d(*) | |||
| real(kind=sp), | intent(in) | :: | du(*) | |||
| real(kind=sp), | intent(in) | :: | du2(*) | |||
| integer(kind=ilp), | intent(in) | :: | ipiv(*) | |||
| real(kind=sp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | trans | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| complex(kind=dp), | intent(in) | :: | dl(*) | |||
| complex(kind=dp), | intent(in) | :: | d(*) | |||
| complex(kind=dp), | intent(in) | :: | du(*) | |||
| complex(kind=dp), | intent(in) | :: | du2(*) | |||
| integer(kind=ilp), | intent(in) | :: | ipiv(*) | |||
| complex(kind=dp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| integer(kind=ilp), | intent(out) | :: | info |
CGTTRS solves one of the systems of equations A * X = B, AT * X = B, or AH * X = B, with a tridiagonal matrix A using the LU factorization computed by CGTTRF.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | trans | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| complex(kind=sp), | intent(in) | :: | dl(*) | |||
| complex(kind=sp), | intent(in) | :: | d(*) | |||
| complex(kind=sp), | intent(in) | :: | du(*) | |||
| complex(kind=sp), | intent(in) | :: | du2(*) | |||
| integer(kind=ilp), | intent(in) | :: | ipiv(*) | |||
| complex(kind=sp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| integer(kind=ilp), | intent(out) | :: | info |
DGTTRS solves one of the systems of equations AX = B or ATX = B, with a tridiagonal matrix A using the LU factorization computed by DGTTRF.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | trans | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| real(kind=dp), | intent(in) | :: | dl(*) | |||
| real(kind=dp), | intent(in) | :: | d(*) | |||
| real(kind=dp), | intent(in) | :: | du(*) | |||
| real(kind=dp), | intent(in) | :: | du2(*) | |||
| integer(kind=ilp), | intent(in) | :: | ipiv(*) | |||
| real(kind=dp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| integer(kind=ilp), | intent(out) | :: | info |
SGTTRS solves one of the systems of equations AX = B or ATX = B, with a tridiagonal matrix A using the LU factorization computed by SGTTRF.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | trans | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| real(kind=sp), | intent(in) | :: | dl(*) | |||
| real(kind=sp), | intent(in) | :: | d(*) | |||
| real(kind=sp), | intent(in) | :: | du(*) | |||
| real(kind=sp), | intent(in) | :: | du2(*) | |||
| integer(kind=ilp), | intent(in) | :: | ipiv(*) | |||
| real(kind=sp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| integer(kind=ilp), | intent(out) | :: | info |
ZGTTRS solves one of the systems of equations A * X = B, AT * X = B, or AH * X = B, with a tridiagonal matrix A using the LU factorization computed by ZGTTRF.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | trans | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| complex(kind=dp), | intent(in) | :: | dl(*) | |||
| complex(kind=dp), | intent(in) | :: | d(*) | |||
| complex(kind=dp), | intent(in) | :: | du(*) | |||
| complex(kind=dp), | intent(in) | :: | du2(*) | |||
| integer(kind=ilp), | intent(in) | :: | ipiv(*) | |||
| complex(kind=dp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| integer(kind=ilp), | intent(out) | :: | info |
HB2ST_KERNELS is an internal routine used by the CHETRD_HB2ST subroutine.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| logical(kind=lk), | intent(in) | :: | wantz | |||
| integer(kind=ilp), | intent(in) | :: | ttype | |||
| integer(kind=ilp), | intent(in) | :: | st | |||
| integer(kind=ilp), | intent(in) | :: | ed | |||
| integer(kind=ilp), | intent(in) | :: | sweep | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nb | |||
| integer(kind=ilp), | intent(in) | :: | ib | |||
| complex(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=sp), | intent(out) | :: | v(*) | |||
| complex(kind=sp), | intent(out) | :: | tau(*) | |||
| integer(kind=ilp), | intent(in) | :: | ldvt | |||
| complex(kind=sp), | intent(out) | :: | work(*) |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| logical(kind=lk), | intent(in) | :: | wantz | |||
| integer(kind=ilp), | intent(in) | :: | ttype | |||
| integer(kind=ilp), | intent(in) | :: | st | |||
| integer(kind=ilp), | intent(in) | :: | ed | |||
| integer(kind=ilp), | intent(in) | :: | sweep | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nb | |||
| integer(kind=ilp), | intent(in) | :: | ib | |||
| complex(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=dp), | intent(out) | :: | v(*) | |||
| complex(kind=dp), | intent(out) | :: | tau(*) | |||
| integer(kind=ilp), | intent(in) | :: | ldvt | |||
| complex(kind=dp), | intent(out) | :: | work(*) |
CHB2ST_KERNELS is an internal routine used by the CHETRD_HB2ST subroutine.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| logical(kind=lk), | intent(in) | :: | wantz | |||
| integer(kind=ilp), | intent(in) | :: | ttype | |||
| integer(kind=ilp), | intent(in) | :: | st | |||
| integer(kind=ilp), | intent(in) | :: | ed | |||
| integer(kind=ilp), | intent(in) | :: | sweep | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nb | |||
| integer(kind=ilp), | intent(in) | :: | ib | |||
| complex(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=sp), | intent(out) | :: | v(*) | |||
| complex(kind=sp), | intent(out) | :: | tau(*) | |||
| integer(kind=ilp), | intent(in) | :: | ldvt | |||
| complex(kind=sp), | intent(out) | :: | work(*) |
ZHB2ST_KERNELS is an internal routine used by the ZHETRD_HB2ST subroutine.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| logical(kind=lk), | intent(in) | :: | wantz | |||
| integer(kind=ilp), | intent(in) | :: | ttype | |||
| integer(kind=ilp), | intent(in) | :: | st | |||
| integer(kind=ilp), | intent(in) | :: | ed | |||
| integer(kind=ilp), | intent(in) | :: | sweep | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nb | |||
| integer(kind=ilp), | intent(in) | :: | ib | |||
| complex(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=dp), | intent(out) | :: | v(*) | |||
| complex(kind=dp), | intent(out) | :: | tau(*) | |||
| integer(kind=ilp), | intent(in) | :: | ldvt | |||
| complex(kind=dp), | intent(out) | :: | work(*) |
HBEV computes all the eigenvalues and, optionally, eigenvectors of a complex Hermitian band matrix A.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | jobz | |||
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | kd | |||
| complex(kind=sp), | intent(inout) | :: | ab(ldab,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldab | |||
| real(kind=sp), | intent(out) | :: | w(*) | |||
| complex(kind=sp), | intent(out) | :: | z(ldz,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldz | |||
| complex(kind=sp), | intent(out) | :: | work(*) | |||
| real(kind=sp), | intent(out) | :: | rwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | jobz | |||
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | kd | |||
| complex(kind=dp), | intent(inout) | :: | ab(ldab,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldab | |||
| real(kind=dp), | intent(out) | :: | w(*) | |||
| complex(kind=dp), | intent(out) | :: | z(ldz,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldz | |||
| complex(kind=dp), | intent(out) | :: | work(*) | |||
| real(kind=dp), | intent(out) | :: | rwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
CHBEV computes all the eigenvalues and, optionally, eigenvectors of a complex Hermitian band matrix A.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | jobz | |||
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | kd | |||
| complex(kind=sp), | intent(inout) | :: | ab(ldab,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldab | |||
| real(kind=sp), | intent(out) | :: | w(*) | |||
| complex(kind=sp), | intent(out) | :: | z(ldz,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldz | |||
| complex(kind=sp), | intent(out) | :: | work(*) | |||
| real(kind=sp), | intent(out) | :: | rwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
ZHBEV computes all the eigenvalues and, optionally, eigenvectors of a complex Hermitian band matrix A.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | jobz | |||
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | kd | |||
| complex(kind=dp), | intent(inout) | :: | ab(ldab,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldab | |||
| real(kind=dp), | intent(out) | :: | w(*) | |||
| complex(kind=dp), | intent(out) | :: | z(ldz,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldz | |||
| complex(kind=dp), | intent(out) | :: | work(*) | |||
| real(kind=dp), | intent(out) | :: | rwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
HBEVD computes all the eigenvalues and, optionally, eigenvectors of a complex Hermitian band matrix A. If eigenvectors are desired, it uses a divide and conquer algorithm. The divide and conquer algorithm makes very mild assumptions about floating point arithmetic. It will work on machines with a guard digit in add/subtract, or on those binary machines without guard digits which subtract like the Cray X-MP, Cray Y-MP, Cray C-90, or Cray-2. It could conceivably fail on hexadecimal or decimal machines without guard digits, but we know of none.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | jobz | |||
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | kd | |||
| complex(kind=sp), | intent(inout) | :: | ab(ldab,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldab | |||
| real(kind=sp), | intent(out) | :: | w(*) | |||
| complex(kind=sp), | intent(out) | :: | z(ldz,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldz | |||
| complex(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| real(kind=sp), | intent(out) | :: | rwork(*) | |||
| integer(kind=ilp), | intent(in) | :: | lrwork | |||
| integer(kind=ilp), | intent(out) | :: | iwork(*) | |||
| integer(kind=ilp), | intent(in) | :: | liwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | jobz | |||
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | kd | |||
| complex(kind=dp), | intent(inout) | :: | ab(ldab,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldab | |||
| real(kind=dp), | intent(out) | :: | w(*) | |||
| complex(kind=dp), | intent(out) | :: | z(ldz,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldz | |||
| complex(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| real(kind=dp), | intent(out) | :: | rwork(*) | |||
| integer(kind=ilp), | intent(in) | :: | lrwork | |||
| integer(kind=ilp), | intent(out) | :: | iwork(*) | |||
| integer(kind=ilp), | intent(in) | :: | liwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
CHBEVD computes all the eigenvalues and, optionally, eigenvectors of a complex Hermitian band matrix A. If eigenvectors are desired, it uses a divide and conquer algorithm. The divide and conquer algorithm makes very mild assumptions about floating point arithmetic. It will work on machines with a guard digit in add/subtract, or on those binary machines without guard digits which subtract like the Cray X-MP, Cray Y-MP, Cray C-90, or Cray-2. It could conceivably fail on hexadecimal or decimal machines without guard digits, but we know of none.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | jobz | |||
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | kd | |||
| complex(kind=sp), | intent(inout) | :: | ab(ldab,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldab | |||
| real(kind=sp), | intent(out) | :: | w(*) | |||
| complex(kind=sp), | intent(out) | :: | z(ldz,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldz | |||
| complex(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| real(kind=sp), | intent(out) | :: | rwork(*) | |||
| integer(kind=ilp), | intent(in) | :: | lrwork | |||
| integer(kind=ilp), | intent(out) | :: | iwork(*) | |||
| integer(kind=ilp), | intent(in) | :: | liwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
ZHBEVD computes all the eigenvalues and, optionally, eigenvectors of a complex Hermitian band matrix A. If eigenvectors are desired, it uses a divide and conquer algorithm. The divide and conquer algorithm makes very mild assumptions about floating point arithmetic. It will work on machines with a guard digit in add/subtract, or on those binary machines without guard digits which subtract like the Cray X-MP, Cray Y-MP, Cray C-90, or Cray-2. It could conceivably fail on hexadecimal or decimal machines without guard digits, but we know of none.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | jobz | |||
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | kd | |||
| complex(kind=dp), | intent(inout) | :: | ab(ldab,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldab | |||
| real(kind=dp), | intent(out) | :: | w(*) | |||
| complex(kind=dp), | intent(out) | :: | z(ldz,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldz | |||
| complex(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| real(kind=dp), | intent(out) | :: | rwork(*) | |||
| integer(kind=ilp), | intent(in) | :: | lrwork | |||
| integer(kind=ilp), | intent(out) | :: | iwork(*) | |||
| integer(kind=ilp), | intent(in) | :: | liwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
HBGST reduces a complex Hermitian-definite banded generalized eigenproblem Ax = lambdaBx to standard form Cy = lambday, such that C has the same bandwidth as A. B must have been previously factorized as SHS by CPBSTF, using a split Cholesky factorization. A is overwritten by C = XHAX, where X = S(-1)*Q and Q is a unitary matrix chosen to preserve the bandwidth of A.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | vect | |||
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | ka | |||
| integer(kind=ilp), | intent(in) | :: | kb | |||
| complex(kind=sp), | intent(inout) | :: | ab(ldab,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldab | |||
| complex(kind=sp), | intent(in) | :: | bb(ldbb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldbb | |||
| complex(kind=sp), | intent(out) | :: | x(ldx,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldx | |||
| complex(kind=sp), | intent(out) | :: | work(*) | |||
| real(kind=sp), | intent(out) | :: | rwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | vect | |||
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | ka | |||
| integer(kind=ilp), | intent(in) | :: | kb | |||
| complex(kind=dp), | intent(inout) | :: | ab(ldab,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldab | |||
| complex(kind=dp), | intent(in) | :: | bb(ldbb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldbb | |||
| complex(kind=dp), | intent(out) | :: | x(ldx,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldx | |||
| complex(kind=dp), | intent(out) | :: | work(*) | |||
| real(kind=dp), | intent(out) | :: | rwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
CHBGST reduces a complex Hermitian-definite banded generalized eigenproblem Ax = lambdaBx to standard form Cy = lambday, such that C has the same bandwidth as A. B must have been previously factorized as SHS by CPBSTF, using a split Cholesky factorization. A is overwritten by C = XHAX, where X = S(-1)*Q and Q is a unitary matrix chosen to preserve the bandwidth of A.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | vect | |||
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | ka | |||
| integer(kind=ilp), | intent(in) | :: | kb | |||
| complex(kind=sp), | intent(inout) | :: | ab(ldab,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldab | |||
| complex(kind=sp), | intent(in) | :: | bb(ldbb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldbb | |||
| complex(kind=sp), | intent(out) | :: | x(ldx,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldx | |||
| complex(kind=sp), | intent(out) | :: | work(*) | |||
| real(kind=sp), | intent(out) | :: | rwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
ZHBGST reduces a complex Hermitian-definite banded generalized eigenproblem Ax = lambdaBx to standard form Cy = lambday, such that C has the same bandwidth as A. B must have been previously factorized as SHS by ZPBSTF, using a split Cholesky factorization. A is overwritten by C = XHAX, where X = S(-1)*Q and Q is a unitary matrix chosen to preserve the bandwidth of A.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | vect | |||
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | ka | |||
| integer(kind=ilp), | intent(in) | :: | kb | |||
| complex(kind=dp), | intent(inout) | :: | ab(ldab,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldab | |||
| complex(kind=dp), | intent(in) | :: | bb(ldbb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldbb | |||
| complex(kind=dp), | intent(out) | :: | x(ldx,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldx | |||
| complex(kind=dp), | intent(out) | :: | work(*) | |||
| real(kind=dp), | intent(out) | :: | rwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
HBGV computes all the eigenvalues, and optionally, the eigenvectors of a complex generalized Hermitian-definite banded eigenproblem, of the form Ax=(lambda)B*x. Here A and B are assumed to be Hermitian and banded, and B is also positive definite.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | jobz | |||
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | ka | |||
| integer(kind=ilp), | intent(in) | :: | kb | |||
| complex(kind=sp), | intent(inout) | :: | ab(ldab,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldab | |||
| complex(kind=sp), | intent(inout) | :: | bb(ldbb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldbb | |||
| real(kind=sp), | intent(out) | :: | w(*) | |||
| complex(kind=sp), | intent(out) | :: | z(ldz,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldz | |||
| complex(kind=sp), | intent(out) | :: | work(*) | |||
| real(kind=sp), | intent(out) | :: | rwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | jobz | |||
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | ka | |||
| integer(kind=ilp), | intent(in) | :: | kb | |||
| complex(kind=dp), | intent(inout) | :: | ab(ldab,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldab | |||
| complex(kind=dp), | intent(inout) | :: | bb(ldbb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldbb | |||
| real(kind=dp), | intent(out) | :: | w(*) | |||
| complex(kind=dp), | intent(out) | :: | z(ldz,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldz | |||
| complex(kind=dp), | intent(out) | :: | work(*) | |||
| real(kind=dp), | intent(out) | :: | rwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
CHBGV computes all the eigenvalues, and optionally, the eigenvectors of a complex generalized Hermitian-definite banded eigenproblem, of the form Ax=(lambda)B*x. Here A and B are assumed to be Hermitian and banded, and B is also positive definite.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | jobz | |||
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | ka | |||
| integer(kind=ilp), | intent(in) | :: | kb | |||
| complex(kind=sp), | intent(inout) | :: | ab(ldab,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldab | |||
| complex(kind=sp), | intent(inout) | :: | bb(ldbb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldbb | |||
| real(kind=sp), | intent(out) | :: | w(*) | |||
| complex(kind=sp), | intent(out) | :: | z(ldz,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldz | |||
| complex(kind=sp), | intent(out) | :: | work(*) | |||
| real(kind=sp), | intent(out) | :: | rwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
ZHBGV computes all the eigenvalues, and optionally, the eigenvectors of a complex generalized Hermitian-definite banded eigenproblem, of the form Ax=(lambda)B*x. Here A and B are assumed to be Hermitian and banded, and B is also positive definite.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | jobz | |||
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | ka | |||
| integer(kind=ilp), | intent(in) | :: | kb | |||
| complex(kind=dp), | intent(inout) | :: | ab(ldab,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldab | |||
| complex(kind=dp), | intent(inout) | :: | bb(ldbb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldbb | |||
| real(kind=dp), | intent(out) | :: | w(*) | |||
| complex(kind=dp), | intent(out) | :: | z(ldz,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldz | |||
| complex(kind=dp), | intent(out) | :: | work(*) | |||
| real(kind=dp), | intent(out) | :: | rwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
HBGVD computes all the eigenvalues, and optionally, the eigenvectors of a complex generalized Hermitian-definite banded eigenproblem, of the form Ax=(lambda)B*x. Here A and B are assumed to be Hermitian and banded, and B is also positive definite. If eigenvectors are desired, it uses a divide and conquer algorithm. The divide and conquer algorithm makes very mild assumptions about floating point arithmetic. It will work on machines with a guard digit in add/subtract, or on those binary machines without guard digits which subtract like the Cray X-MP, Cray Y-MP, Cray C-90, or Cray-2. It could conceivably fail on hexadecimal or decimal machines without guard digits, but we know of none.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | jobz | |||
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | ka | |||
| integer(kind=ilp), | intent(in) | :: | kb | |||
| complex(kind=sp), | intent(inout) | :: | ab(ldab,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldab | |||
| complex(kind=sp), | intent(inout) | :: | bb(ldbb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldbb | |||
| real(kind=sp), | intent(out) | :: | w(*) | |||
| complex(kind=sp), | intent(out) | :: | z(ldz,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldz | |||
| complex(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| real(kind=sp), | intent(out) | :: | rwork(*) | |||
| integer(kind=ilp), | intent(in) | :: | lrwork | |||
| integer(kind=ilp), | intent(out) | :: | iwork(*) | |||
| integer(kind=ilp), | intent(in) | :: | liwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | jobz | |||
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | ka | |||
| integer(kind=ilp), | intent(in) | :: | kb | |||
| complex(kind=dp), | intent(inout) | :: | ab(ldab,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldab | |||
| complex(kind=dp), | intent(inout) | :: | bb(ldbb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldbb | |||
| real(kind=dp), | intent(out) | :: | w(*) | |||
| complex(kind=dp), | intent(out) | :: | z(ldz,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldz | |||
| complex(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| real(kind=dp), | intent(out) | :: | rwork(*) | |||
| integer(kind=ilp), | intent(in) | :: | lrwork | |||
| integer(kind=ilp), | intent(out) | :: | iwork(*) | |||
| integer(kind=ilp), | intent(in) | :: | liwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
CHBGVD computes all the eigenvalues, and optionally, the eigenvectors of a complex generalized Hermitian-definite banded eigenproblem, of the form Ax=(lambda)B*x. Here A and B are assumed to be Hermitian and banded, and B is also positive definite. If eigenvectors are desired, it uses a divide and conquer algorithm. The divide and conquer algorithm makes very mild assumptions about floating point arithmetic. It will work on machines with a guard digit in add/subtract, or on those binary machines without guard digits which subtract like the Cray X-MP, Cray Y-MP, Cray C-90, or Cray-2. It could conceivably fail on hexadecimal or decimal machines without guard digits, but we know of none.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | jobz | |||
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | ka | |||
| integer(kind=ilp), | intent(in) | :: | kb | |||
| complex(kind=sp), | intent(inout) | :: | ab(ldab,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldab | |||
| complex(kind=sp), | intent(inout) | :: | bb(ldbb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldbb | |||
| real(kind=sp), | intent(out) | :: | w(*) | |||
| complex(kind=sp), | intent(out) | :: | z(ldz,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldz | |||
| complex(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| real(kind=sp), | intent(out) | :: | rwork(*) | |||
| integer(kind=ilp), | intent(in) | :: | lrwork | |||
| integer(kind=ilp), | intent(out) | :: | iwork(*) | |||
| integer(kind=ilp), | intent(in) | :: | liwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
ZHBGVD computes all the eigenvalues, and optionally, the eigenvectors of a complex generalized Hermitian-definite banded eigenproblem, of the form Ax=(lambda)B*x. Here A and B are assumed to be Hermitian and banded, and B is also positive definite. If eigenvectors are desired, it uses a divide and conquer algorithm. The divide and conquer algorithm makes very mild assumptions about floating point arithmetic. It will work on machines with a guard digit in add/subtract, or on those binary machines without guard digits which subtract like the Cray X-MP, Cray Y-MP, Cray C-90, or Cray-2. It could conceivably fail on hexadecimal or decimal machines without guard digits, but we know of none.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | jobz | |||
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | ka | |||
| integer(kind=ilp), | intent(in) | :: | kb | |||
| complex(kind=dp), | intent(inout) | :: | ab(ldab,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldab | |||
| complex(kind=dp), | intent(inout) | :: | bb(ldbb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldbb | |||
| real(kind=dp), | intent(out) | :: | w(*) | |||
| complex(kind=dp), | intent(out) | :: | z(ldz,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldz | |||
| complex(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| real(kind=dp), | intent(out) | :: | rwork(*) | |||
| integer(kind=ilp), | intent(in) | :: | lrwork | |||
| integer(kind=ilp), | intent(out) | :: | iwork(*) | |||
| integer(kind=ilp), | intent(in) | :: | liwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
HBTRD reduces a complex Hermitian band matrix A to real symmetric tridiagonal form T by a unitary similarity transformation: Q**H * A * Q = T.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | vect | |||
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | kd | |||
| complex(kind=sp), | intent(inout) | :: | ab(ldab,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldab | |||
| real(kind=sp), | intent(out) | :: | d(*) | |||
| real(kind=sp), | intent(out) | :: | e(*) | |||
| complex(kind=sp), | intent(inout) | :: | q(ldq,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldq | |||
| complex(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | vect | |||
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | kd | |||
| complex(kind=dp), | intent(inout) | :: | ab(ldab,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldab | |||
| real(kind=dp), | intent(out) | :: | d(*) | |||
| real(kind=dp), | intent(out) | :: | e(*) | |||
| complex(kind=dp), | intent(inout) | :: | q(ldq,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldq | |||
| complex(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
CHBTRD reduces a complex Hermitian band matrix A to real symmetric tridiagonal form T by a unitary similarity transformation: Q**H * A * Q = T.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | vect | |||
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | kd | |||
| complex(kind=sp), | intent(inout) | :: | ab(ldab,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldab | |||
| real(kind=sp), | intent(out) | :: | d(*) | |||
| real(kind=sp), | intent(out) | :: | e(*) | |||
| complex(kind=sp), | intent(inout) | :: | q(ldq,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldq | |||
| complex(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
ZHBTRD reduces a complex Hermitian band matrix A to real symmetric tridiagonal form T by a unitary similarity transformation: Q**H * A * Q = T.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | vect | |||
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | kd | |||
| complex(kind=dp), | intent(inout) | :: | ab(ldab,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldab | |||
| real(kind=dp), | intent(out) | :: | d(*) | |||
| real(kind=dp), | intent(out) | :: | e(*) | |||
| complex(kind=dp), | intent(inout) | :: | q(ldq,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldq | |||
| complex(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
HECON estimates the reciprocal of the condition number of a complex Hermitian matrix A using the factorization A = UDUH or A = LDLH computed by CHETRF. An estimate is obtained for norm(inv(A)), and the reciprocal of the condition number is computed as RCOND = 1 / (ANORM * norm(inv(A))).
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=sp), | intent(in) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| integer(kind=ilp), | intent(in) | :: | ipiv(*) | |||
| real(kind=sp), | intent(in) | :: | anorm | |||
| real(kind=sp), | intent(out) | :: | rcond | |||
| complex(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=dp), | intent(in) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| integer(kind=ilp), | intent(in) | :: | ipiv(*) | |||
| real(kind=dp), | intent(in) | :: | anorm | |||
| real(kind=dp), | intent(out) | :: | rcond | |||
| complex(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
CHECON estimates the reciprocal of the condition number of a complex Hermitian matrix A using the factorization A = UDUH or A = LDLH computed by CHETRF. An estimate is obtained for norm(inv(A)), and the reciprocal of the condition number is computed as RCOND = 1 / (ANORM * norm(inv(A))).
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=sp), | intent(in) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| integer(kind=ilp), | intent(in) | :: | ipiv(*) | |||
| real(kind=sp), | intent(in) | :: | anorm | |||
| real(kind=sp), | intent(out) | :: | rcond | |||
| complex(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
ZHECON estimates the reciprocal of the condition number of a complex Hermitian matrix A using the factorization A = UDUH or A = LDLH computed by ZHETRF. An estimate is obtained for norm(inv(A)), and the reciprocal of the condition number is computed as RCOND = 1 / (ANORM * norm(inv(A))).
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=dp), | intent(in) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| integer(kind=ilp), | intent(in) | :: | ipiv(*) | |||
| real(kind=dp), | intent(in) | :: | anorm | |||
| real(kind=dp), | intent(out) | :: | rcond | |||
| complex(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
HECON_ROOK estimates the reciprocal of the condition number of a complex Hermitian matrix A using the factorization A = UDUH or A = LDLH computed by CHETRF_ROOK. An estimate is obtained for norm(inv(A)), and the reciprocal of the condition number is computed as RCOND = 1 / (ANORM * norm(inv(A))).
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=sp), | intent(in) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| integer(kind=ilp), | intent(in) | :: | ipiv(*) | |||
| real(kind=sp), | intent(in) | :: | anorm | |||
| real(kind=sp), | intent(out) | :: | rcond | |||
| complex(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=dp), | intent(in) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| integer(kind=ilp), | intent(in) | :: | ipiv(*) | |||
| real(kind=dp), | intent(in) | :: | anorm | |||
| real(kind=dp), | intent(out) | :: | rcond | |||
| complex(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
CHECON_ROOK estimates the reciprocal of the condition number of a complex Hermitian matrix A using the factorization A = UDUH or A = LDLH computed by CHETRF_ROOK. An estimate is obtained for norm(inv(A)), and the reciprocal of the condition number is computed as RCOND = 1 / (ANORM * norm(inv(A))).
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=sp), | intent(in) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| integer(kind=ilp), | intent(in) | :: | ipiv(*) | |||
| real(kind=sp), | intent(in) | :: | anorm | |||
| real(kind=sp), | intent(out) | :: | rcond | |||
| complex(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
ZHECON_ROOK estimates the reciprocal of the condition number of a complex Hermitian matrix A using the factorization A = UDUH or A = LDLH computed by CHETRF_ROOK. An estimate is obtained for norm(inv(A)), and the reciprocal of the condition number is computed as RCOND = 1 / (ANORM * norm(inv(A))).
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=dp), | intent(in) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| integer(kind=ilp), | intent(in) | :: | ipiv(*) | |||
| real(kind=dp), | intent(in) | :: | anorm | |||
| real(kind=dp), | intent(out) | :: | rcond | |||
| complex(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
HEEQUB computes row and column scalings intended to equilibrate a Hermitian matrix A (with respect to the Euclidean norm) and reduce its condition number. The scale factors S are computed by the BIN algorithm (see references) so that the scaled matrix B with elements B(i,j) = S(i)A(i,j)S(j) has a condition number within a factor N of the smallest possible condition number over all possible diagonal scalings.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=sp), | intent(in) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=sp), | intent(out) | :: | s(*) | |||
| real(kind=sp), | intent(out) | :: | scond | |||
| real(kind=sp), | intent(out) | :: | amax | |||
| complex(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=dp), | intent(in) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=dp), | intent(out) | :: | s(*) | |||
| real(kind=dp), | intent(out) | :: | scond | |||
| real(kind=dp), | intent(out) | :: | amax | |||
| complex(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
CHEEQUB computes row and column scalings intended to equilibrate a Hermitian matrix A (with respect to the Euclidean norm) and reduce its condition number. The scale factors S are computed by the BIN algorithm (see references) so that the scaled matrix B with elements B(i,j) = S(i)A(i,j)S(j) has a condition number within a factor N of the smallest possible condition number over all possible diagonal scalings.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=sp), | intent(in) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=sp), | intent(out) | :: | s(*) | |||
| real(kind=sp), | intent(out) | :: | scond | |||
| real(kind=sp), | intent(out) | :: | amax | |||
| complex(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
ZHEEQUB computes row and column scalings intended to equilibrate a Hermitian matrix A (with respect to the Euclidean norm) and reduce its condition number. The scale factors S are computed by the BIN algorithm (see references) so that the scaled matrix B with elements B(i,j) = S(i)A(i,j)S(j) has a condition number within a factor N of the smallest possible condition number over all possible diagonal scalings.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=dp), | intent(in) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=dp), | intent(out) | :: | s(*) | |||
| real(kind=dp), | intent(out) | :: | scond | |||
| real(kind=dp), | intent(out) | :: | amax | |||
| complex(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
HEEV computes all eigenvalues and, optionally, eigenvectors of a complex Hermitian matrix A.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | jobz | |||
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=sp), | intent(out) | :: | w(*) | |||
| complex(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| real(kind=sp), | intent(out) | :: | rwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | jobz | |||
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=dp), | intent(out) | :: | w(*) | |||
| complex(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| real(kind=dp), | intent(out) | :: | rwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
CHEEV computes all eigenvalues and, optionally, eigenvectors of a complex Hermitian matrix A.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | jobz | |||
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=sp), | intent(out) | :: | w(*) | |||
| complex(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| real(kind=sp), | intent(out) | :: | rwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
ZHEEV computes all eigenvalues and, optionally, eigenvectors of a complex Hermitian matrix A.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | jobz | |||
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=dp), | intent(out) | :: | w(*) | |||
| complex(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| real(kind=dp), | intent(out) | :: | rwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
HEEVD computes all eigenvalues and, optionally, eigenvectors of a complex Hermitian matrix A. If eigenvectors are desired, it uses a divide and conquer algorithm. The divide and conquer algorithm makes very mild assumptions about floating point arithmetic. It will work on machines with a guard digit in add/subtract, or on those binary machines without guard digits which subtract like the Cray X-MP, Cray Y-MP, Cray C-90, or Cray-2. It could conceivably fail on hexadecimal or decimal machines without guard digits, but we know of none.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | jobz | |||
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=sp), | intent(out) | :: | w(*) | |||
| complex(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| real(kind=sp), | intent(out) | :: | rwork(*) | |||
| integer(kind=ilp), | intent(in) | :: | lrwork | |||
| integer(kind=ilp), | intent(out) | :: | iwork(*) | |||
| integer(kind=ilp), | intent(in) | :: | liwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | jobz | |||
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=dp), | intent(out) | :: | w(*) | |||
| complex(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| real(kind=dp), | intent(out) | :: | rwork(*) | |||
| integer(kind=ilp), | intent(in) | :: | lrwork | |||
| integer(kind=ilp), | intent(out) | :: | iwork(*) | |||
| integer(kind=ilp), | intent(in) | :: | liwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
CHEEVD computes all eigenvalues and, optionally, eigenvectors of a complex Hermitian matrix A. If eigenvectors are desired, it uses a divide and conquer algorithm. The divide and conquer algorithm makes very mild assumptions about floating point arithmetic. It will work on machines with a guard digit in add/subtract, or on those binary machines without guard digits which subtract like the Cray X-MP, Cray Y-MP, Cray C-90, or Cray-2. It could conceivably fail on hexadecimal or decimal machines without guard digits, but we know of none.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | jobz | |||
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=sp), | intent(out) | :: | w(*) | |||
| complex(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| real(kind=sp), | intent(out) | :: | rwork(*) | |||
| integer(kind=ilp), | intent(in) | :: | lrwork | |||
| integer(kind=ilp), | intent(out) | :: | iwork(*) | |||
| integer(kind=ilp), | intent(in) | :: | liwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
ZHEEVD computes all eigenvalues and, optionally, eigenvectors of a complex Hermitian matrix A. If eigenvectors are desired, it uses a divide and conquer algorithm. The divide and conquer algorithm makes very mild assumptions about floating point arithmetic. It will work on machines with a guard digit in add/subtract, or on those binary machines without guard digits which subtract like the Cray X-MP, Cray Y-MP, Cray C-90, or Cray-2. It could conceivably fail on hexadecimal or decimal machines without guard digits, but we know of none.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | jobz | |||
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=dp), | intent(out) | :: | w(*) | |||
| complex(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| real(kind=dp), | intent(out) | :: | rwork(*) | |||
| integer(kind=ilp), | intent(in) | :: | lrwork | |||
| integer(kind=ilp), | intent(out) | :: | iwork(*) | |||
| integer(kind=ilp), | intent(in) | :: | liwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
HEEVR computes selected eigenvalues and, optionally, eigenvectors of a complex Hermitian matrix A. Eigenvalues and eigenvectors can be selected by specifying either a range of values or a range of indices for the desired eigenvalues. HEEVR first reduces the matrix A to tridiagonal form T with a call to CHETRD. Then, whenever possible, HEEVR calls CSTEMR to compute the eigenspectrum using Relatively Robust Representations. CSTEMR computes eigenvalues by the dqds algorithm, while orthogonal eigenvectors are computed from various "good" L D L^T representations (also known as Relatively Robust Representations). Gram-Schmidt orthogonalization is avoided as far as possible. More specifically, the various steps of the algorithm are as follows. For each unreduced block (submatrix) of T, (a) Compute T - sigma I = L D L^T, so that L and D define all the wanted eigenvalues to high relative accuracy. This means that small relative changes in the entries of D and L cause only small relative changes in the eigenvalues and eigenvectors. The standard (unfactored) representation of the tridiagonal matrix T does not have this property in general. (b) Compute the eigenvalues to suitable accuracy. If the eigenvectors are desired, the algorithm attains full accuracy of the computed eigenvalues only right before the corresponding vectors have to be computed, see steps c) and d). (c) For each cluster of close eigenvalues, select a new shift close to the cluster, find a new factorization, and refine the shifted eigenvalues to suitable accuracy. (d) For each eigenvalue with a large enough relative separation compute the corresponding eigenvector by forming a rank revealing twisted factorization. Go back to (c) for any clusters that remain. The desired accuracy of the output can be specified by the input parameter ABSTOL. For more details, see CSTEMR's documentation and: - Inderjit S. Dhillon and Beresford N. Parlett: "Multiple representations to compute orthogonal eigenvectors of symmetric tridiagonal matrices," Linear Algebra and its Applications, 387(1), pp. 1-28, August 2004. - Inderjit Dhillon and Beresford Parlett: "Orthogonal Eigenvectors and Relative Gaps," SIAM Journal on Matrix Analysis and Applications, Vol. 25, 2004. Also LAPACK Working Note 154. - Inderjit Dhillon: "A new O(n^2) algorithm for the symmetric tridiagonal eigenvalue/eigenvector problem", Computer Science Division Technical Report No. UCB/CSD-97-971, UC Berkeley, May 1997. Note 1 : HEEVR calls CSTEMR when the full spectrum is requested on machines which conform to the ieee-754 floating point standard. HEEVR calls SSTEBZ and CSTEIN on non-ieee machines and when partial spectrum requests are made. Normal execution of CSTEMR may create NaNs and infinities and hence may abort due to a floating point exception in environments which do not handle NaNs and infinities in the ieee standard default manner.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | jobz | |||
| character, | intent(in) | :: | range | |||
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=sp), | intent(in) | :: | vl | |||
| real(kind=sp), | intent(in) | :: | vu | |||
| integer(kind=ilp), | intent(in) | :: | il | |||
| integer(kind=ilp), | intent(in) | :: | iu | |||
| real(kind=sp), | intent(in) | :: | abstol | |||
| integer(kind=ilp), | intent(out) | :: | m | |||
| real(kind=sp), | intent(out) | :: | w(*) | |||
| complex(kind=sp), | intent(out) | :: | z(ldz,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldz | |||
| integer(kind=ilp), | intent(out) | :: | isuppz(*) | |||
| complex(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| real(kind=sp), | intent(out) | :: | rwork(*) | |||
| integer(kind=ilp), | intent(in) | :: | lrwork | |||
| integer(kind=ilp), | intent(out) | :: | iwork(*) | |||
| integer(kind=ilp), | intent(in) | :: | liwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | jobz | |||
| character, | intent(in) | :: | range | |||
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=dp), | intent(in) | :: | vl | |||
| real(kind=dp), | intent(in) | :: | vu | |||
| integer(kind=ilp), | intent(in) | :: | il | |||
| integer(kind=ilp), | intent(in) | :: | iu | |||
| real(kind=dp), | intent(in) | :: | abstol | |||
| integer(kind=ilp), | intent(out) | :: | m | |||
| real(kind=dp), | intent(out) | :: | w(*) | |||
| complex(kind=dp), | intent(out) | :: | z(ldz,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldz | |||
| integer(kind=ilp), | intent(out) | :: | isuppz(*) | |||
| complex(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| real(kind=dp), | intent(out) | :: | rwork(*) | |||
| integer(kind=ilp), | intent(in) | :: | lrwork | |||
| integer(kind=ilp), | intent(out) | :: | iwork(*) | |||
| integer(kind=ilp), | intent(in) | :: | liwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
CHEEVR computes selected eigenvalues and, optionally, eigenvectors of a complex Hermitian matrix A. Eigenvalues and eigenvectors can be selected by specifying either a range of values or a range of indices for the desired eigenvalues. CHEEVR first reduces the matrix A to tridiagonal form T with a call to CHETRD. Then, whenever possible, CHEEVR calls CSTEMR to compute the eigenspectrum using Relatively Robust Representations. CSTEMR computes eigenvalues by the dqds algorithm, while orthogonal eigenvectors are computed from various "good" L D L^T representations (also known as Relatively Robust Representations). Gram-Schmidt orthogonalization is avoided as far as possible. More specifically, the various steps of the algorithm are as follows. For each unreduced block (submatrix) of T, (a) Compute T - sigma I = L D L^T, so that L and D define all the wanted eigenvalues to high relative accuracy. This means that small relative changes in the entries of D and L cause only small relative changes in the eigenvalues and eigenvectors. The standard (unfactored) representation of the tridiagonal matrix T does not have this property in general. (b) Compute the eigenvalues to suitable accuracy. If the eigenvectors are desired, the algorithm attains full accuracy of the computed eigenvalues only right before the corresponding vectors have to be computed, see steps c) and d). (c) For each cluster of close eigenvalues, select a new shift close to the cluster, find a new factorization, and refine the shifted eigenvalues to suitable accuracy. (d) For each eigenvalue with a large enough relative separation compute the corresponding eigenvector by forming a rank revealing twisted factorization. Go back to (c) for any clusters that remain. The desired accuracy of the output can be specified by the input parameter ABSTOL. For more details, see CSTEMR's documentation and: - Inderjit S. Dhillon and Beresford N. Parlett: "Multiple representations to compute orthogonal eigenvectors of symmetric tridiagonal matrices," Linear Algebra and its Applications, 387(1), pp. 1-28, August 2004. - Inderjit Dhillon and Beresford Parlett: "Orthogonal Eigenvectors and Relative Gaps," SIAM Journal on Matrix Analysis and Applications, Vol. 25, 2004. Also LAPACK Working Note 154. - Inderjit Dhillon: "A new O(n^2) algorithm for the symmetric tridiagonal eigenvalue/eigenvector problem", Computer Science Division Technical Report No. UCB/CSD-97-971, UC Berkeley, May 1997. Note 1 : CHEEVR calls CSTEMR when the full spectrum is requested on machines which conform to the ieee-754 floating point standard. CHEEVR calls SSTEBZ and CSTEIN on non-ieee machines and when partial spectrum requests are made. Normal execution of CSTEMR may create NaNs and infinities and hence may abort due to a floating point exception in environments which do not handle NaNs and infinities in the ieee standard default manner.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | jobz | |||
| character, | intent(in) | :: | range | |||
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=sp), | intent(in) | :: | vl | |||
| real(kind=sp), | intent(in) | :: | vu | |||
| integer(kind=ilp), | intent(in) | :: | il | |||
| integer(kind=ilp), | intent(in) | :: | iu | |||
| real(kind=sp), | intent(in) | :: | abstol | |||
| integer(kind=ilp), | intent(out) | :: | m | |||
| real(kind=sp), | intent(out) | :: | w(*) | |||
| complex(kind=sp), | intent(out) | :: | z(ldz,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldz | |||
| integer(kind=ilp), | intent(out) | :: | isuppz(*) | |||
| complex(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| real(kind=sp), | intent(out) | :: | rwork(*) | |||
| integer(kind=ilp), | intent(in) | :: | lrwork | |||
| integer(kind=ilp), | intent(out) | :: | iwork(*) | |||
| integer(kind=ilp), | intent(in) | :: | liwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
ZHEEVR computes selected eigenvalues and, optionally, eigenvectors of a complex Hermitian matrix A. Eigenvalues and eigenvectors can be selected by specifying either a range of values or a range of indices for the desired eigenvalues. ZHEEVR first reduces the matrix A to tridiagonal form T with a call to ZHETRD. Then, whenever possible, ZHEEVR calls ZSTEMR to compute eigenspectrum using Relatively Robust Representations. ZSTEMR computes eigenvalues by the dqds algorithm, while orthogonal eigenvectors are computed from various "good" L D L^T representations (also known as Relatively Robust Representations). Gram-Schmidt orthogonalization is avoided as far as possible. More specifically, the various steps of the algorithm are as follows. For each unreduced block (submatrix) of T, (a) Compute T - sigma I = L D L^T, so that L and D define all the wanted eigenvalues to high relative accuracy. This means that small relative changes in the entries of D and L cause only small relative changes in the eigenvalues and eigenvectors. The standard (unfactored) representation of the tridiagonal matrix T does not have this property in general. (b) Compute the eigenvalues to suitable accuracy. If the eigenvectors are desired, the algorithm attains full accuracy of the computed eigenvalues only right before the corresponding vectors have to be computed, see steps c) and d). (c) For each cluster of close eigenvalues, select a new shift close to the cluster, find a new factorization, and refine the shifted eigenvalues to suitable accuracy. (d) For each eigenvalue with a large enough relative separation compute the corresponding eigenvector by forming a rank revealing twisted factorization. Go back to (c) for any clusters that remain. The desired accuracy of the output can be specified by the input parameter ABSTOL. For more details, see ZSTEMR's documentation and: - Inderjit S. Dhillon and Beresford N. Parlett: "Multiple representations to compute orthogonal eigenvectors of symmetric tridiagonal matrices," Linear Algebra and its Applications, 387(1), pp. 1-28, August 2004. - Inderjit Dhillon and Beresford Parlett: "Orthogonal Eigenvectors and Relative Gaps," SIAM Journal on Matrix Analysis and Applications, Vol. 25, 2004. Also LAPACK Working Note 154. - Inderjit Dhillon: "A new O(n^2) algorithm for the symmetric tridiagonal eigenvalue/eigenvector problem", Computer Science Division Technical Report No. UCB/CSD-97-971, UC Berkeley, May 1997. Note 1 : ZHEEVR calls ZSTEMR when the full spectrum is requested on machines which conform to the ieee-754 floating point standard. ZHEEVR calls DSTEBZ and ZSTEIN on non-ieee machines and when partial spectrum requests are made. Normal execution of ZSTEMR may create NaNs and infinities and hence may abort due to a floating point exception in environments which do not handle NaNs and infinities in the ieee standard default manner.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | jobz | |||
| character, | intent(in) | :: | range | |||
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=dp), | intent(in) | :: | vl | |||
| real(kind=dp), | intent(in) | :: | vu | |||
| integer(kind=ilp), | intent(in) | :: | il | |||
| integer(kind=ilp), | intent(in) | :: | iu | |||
| real(kind=dp), | intent(in) | :: | abstol | |||
| integer(kind=ilp), | intent(out) | :: | m | |||
| real(kind=dp), | intent(out) | :: | w(*) | |||
| complex(kind=dp), | intent(out) | :: | z(ldz,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldz | |||
| integer(kind=ilp), | intent(out) | :: | isuppz(*) | |||
| complex(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| real(kind=dp), | intent(out) | :: | rwork(*) | |||
| integer(kind=ilp), | intent(in) | :: | lrwork | |||
| integer(kind=ilp), | intent(out) | :: | iwork(*) | |||
| integer(kind=ilp), | intent(in) | :: | liwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
HEGST reduces a complex Hermitian-definite generalized eigenproblem to standard form. If ITYPE = 1, the problem is Ax = lambdaBx, and A is overwritten by inv(UH)Ainv(U) or inv(L)Ainv(LH) If ITYPE = 2 or 3, the problem is ABx = lambdax or BAx = lambdax, and A is overwritten by UAUH or LHAL. B must have been previously factorized as UHU or LL*H by CPOTRF.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | itype | |||
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=sp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | itype | |||
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=dp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| integer(kind=ilp), | intent(out) | :: | info |
CHEGST reduces a complex Hermitian-definite generalized eigenproblem to standard form. If ITYPE = 1, the problem is Ax = lambdaBx, and A is overwritten by inv(UH)Ainv(U) or inv(L)Ainv(LH) If ITYPE = 2 or 3, the problem is ABx = lambdax or BAx = lambdax, and A is overwritten by UAUH or LHAL. B must have been previously factorized as UHU or LL*H by CPOTRF.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | itype | |||
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=sp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| integer(kind=ilp), | intent(out) | :: | info |
ZHEGST reduces a complex Hermitian-definite generalized eigenproblem to standard form. If ITYPE = 1, the problem is Ax = lambdaBx, and A is overwritten by inv(UH)Ainv(U) or inv(L)Ainv(LH) If ITYPE = 2 or 3, the problem is ABx = lambdax or BAx = lambdax, and A is overwritten by UAUH or LHAL. B must have been previously factorized as UHU or LL*H by ZPOTRF.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | itype | |||
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=dp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| integer(kind=ilp), | intent(out) | :: | info |
HEGV computes all the eigenvalues, and optionally, the eigenvectors of a complex generalized Hermitian-definite eigenproblem, of the form Ax=(lambda)Bx, ABx=(lambda)x, or BAx=(lambda)x. Here A and B are assumed to be Hermitian and B is also positive definite.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | itype | |||
| character, | intent(in) | :: | jobz | |||
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=sp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| real(kind=sp), | intent(out) | :: | w(*) | |||
| complex(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| real(kind=sp), | intent(out) | :: | rwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | itype | |||
| character, | intent(in) | :: | jobz | |||
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=dp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| real(kind=dp), | intent(out) | :: | w(*) | |||
| complex(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| real(kind=dp), | intent(out) | :: | rwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
CHEGV computes all the eigenvalues, and optionally, the eigenvectors of a complex generalized Hermitian-definite eigenproblem, of the form Ax=(lambda)Bx, ABx=(lambda)x, or BAx=(lambda)x. Here A and B are assumed to be Hermitian and B is also positive definite.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | itype | |||
| character, | intent(in) | :: | jobz | |||
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=sp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| real(kind=sp), | intent(out) | :: | w(*) | |||
| complex(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| real(kind=sp), | intent(out) | :: | rwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
ZHEGV computes all the eigenvalues, and optionally, the eigenvectors of a complex generalized Hermitian-definite eigenproblem, of the form Ax=(lambda)Bx, ABx=(lambda)x, or BAx=(lambda)x. Here A and B are assumed to be Hermitian and B is also positive definite.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | itype | |||
| character, | intent(in) | :: | jobz | |||
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=dp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| real(kind=dp), | intent(out) | :: | w(*) | |||
| complex(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| real(kind=dp), | intent(out) | :: | rwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
HEGVD computes all the eigenvalues, and optionally, the eigenvectors of a complex generalized Hermitian-definite eigenproblem, of the form Ax=(lambda)Bx, ABx=(lambda)x, or BAx=(lambda)x. Here A and B are assumed to be Hermitian and B is also positive definite. If eigenvectors are desired, it uses a divide and conquer algorithm. The divide and conquer algorithm makes very mild assumptions about floating point arithmetic. It will work on machines with a guard digit in add/subtract, or on those binary machines without guard digits which subtract like the Cray X-MP, Cray Y-MP, Cray C-90, or Cray-2. It could conceivably fail on hexadecimal or decimal machines without guard digits, but we know of none.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | itype | |||
| character, | intent(in) | :: | jobz | |||
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=sp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| real(kind=sp), | intent(out) | :: | w(*) | |||
| complex(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| real(kind=sp), | intent(out) | :: | rwork(*) | |||
| integer(kind=ilp), | intent(in) | :: | lrwork | |||
| integer(kind=ilp), | intent(out) | :: | iwork(*) | |||
| integer(kind=ilp), | intent(in) | :: | liwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | itype | |||
| character, | intent(in) | :: | jobz | |||
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=dp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| real(kind=dp), | intent(out) | :: | w(*) | |||
| complex(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| real(kind=dp), | intent(out) | :: | rwork(*) | |||
| integer(kind=ilp), | intent(in) | :: | lrwork | |||
| integer(kind=ilp), | intent(out) | :: | iwork(*) | |||
| integer(kind=ilp), | intent(in) | :: | liwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
CHEGVD computes all the eigenvalues, and optionally, the eigenvectors of a complex generalized Hermitian-definite eigenproblem, of the form Ax=(lambda)Bx, ABx=(lambda)x, or BAx=(lambda)x. Here A and B are assumed to be Hermitian and B is also positive definite. If eigenvectors are desired, it uses a divide and conquer algorithm. The divide and conquer algorithm makes very mild assumptions about floating point arithmetic. It will work on machines with a guard digit in add/subtract, or on those binary machines without guard digits which subtract like the Cray X-MP, Cray Y-MP, Cray C-90, or Cray-2. It could conceivably fail on hexadecimal or decimal machines without guard digits, but we know of none.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | itype | |||
| character, | intent(in) | :: | jobz | |||
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=sp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| real(kind=sp), | intent(out) | :: | w(*) | |||
| complex(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| real(kind=sp), | intent(out) | :: | rwork(*) | |||
| integer(kind=ilp), | intent(in) | :: | lrwork | |||
| integer(kind=ilp), | intent(out) | :: | iwork(*) | |||
| integer(kind=ilp), | intent(in) | :: | liwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
ZHEGVD computes all the eigenvalues, and optionally, the eigenvectors of a complex generalized Hermitian-definite eigenproblem, of the form Ax=(lambda)Bx, ABx=(lambda)x, or BAx=(lambda)x. Here A and B are assumed to be Hermitian and B is also positive definite. If eigenvectors are desired, it uses a divide and conquer algorithm. The divide and conquer algorithm makes very mild assumptions about floating point arithmetic. It will work on machines with a guard digit in add/subtract, or on those binary machines without guard digits which subtract like the Cray X-MP, Cray Y-MP, Cray C-90, or Cray-2. It could conceivably fail on hexadecimal or decimal machines without guard digits, but we know of none.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | itype | |||
| character, | intent(in) | :: | jobz | |||
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=dp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| real(kind=dp), | intent(out) | :: | w(*) | |||
| complex(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| real(kind=dp), | intent(out) | :: | rwork(*) | |||
| integer(kind=ilp), | intent(in) | :: | lrwork | |||
| integer(kind=ilp), | intent(out) | :: | iwork(*) | |||
| integer(kind=ilp), | intent(in) | :: | liwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
HERFS improves the computed solution to a system of linear equations when the coefficient matrix is Hermitian indefinite, and provides error bounds and backward error estimates for the solution.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| complex(kind=sp), | intent(in) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=sp), | intent(in) | :: | af(ldaf,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldaf | |||
| integer(kind=ilp), | intent(in) | :: | ipiv(*) | |||
| complex(kind=sp), | intent(in) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| complex(kind=sp), | intent(inout) | :: | x(ldx,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldx | |||
| real(kind=sp), | intent(out) | :: | ferr(*) | |||
| real(kind=sp), | intent(out) | :: | berr(*) | |||
| complex(kind=sp), | intent(out) | :: | work(*) | |||
| real(kind=sp), | intent(out) | :: | rwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| complex(kind=dp), | intent(in) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=dp), | intent(in) | :: | af(ldaf,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldaf | |||
| integer(kind=ilp), | intent(in) | :: | ipiv(*) | |||
| complex(kind=dp), | intent(in) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| complex(kind=dp), | intent(inout) | :: | x(ldx,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldx | |||
| real(kind=dp), | intent(out) | :: | ferr(*) | |||
| real(kind=dp), | intent(out) | :: | berr(*) | |||
| complex(kind=dp), | intent(out) | :: | work(*) | |||
| real(kind=dp), | intent(out) | :: | rwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
CHERFS improves the computed solution to a system of linear equations when the coefficient matrix is Hermitian indefinite, and provides error bounds and backward error estimates for the solution.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| complex(kind=sp), | intent(in) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=sp), | intent(in) | :: | af(ldaf,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldaf | |||
| integer(kind=ilp), | intent(in) | :: | ipiv(*) | |||
| complex(kind=sp), | intent(in) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| complex(kind=sp), | intent(inout) | :: | x(ldx,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldx | |||
| real(kind=sp), | intent(out) | :: | ferr(*) | |||
| real(kind=sp), | intent(out) | :: | berr(*) | |||
| complex(kind=sp), | intent(out) | :: | work(*) | |||
| real(kind=sp), | intent(out) | :: | rwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
ZHERFS improves the computed solution to a system of linear equations when the coefficient matrix is Hermitian indefinite, and provides error bounds and backward error estimates for the solution.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| complex(kind=dp), | intent(in) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=dp), | intent(in) | :: | af(ldaf,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldaf | |||
| integer(kind=ilp), | intent(in) | :: | ipiv(*) | |||
| complex(kind=dp), | intent(in) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| complex(kind=dp), | intent(inout) | :: | x(ldx,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldx | |||
| real(kind=dp), | intent(out) | :: | ferr(*) | |||
| real(kind=dp), | intent(out) | :: | berr(*) | |||
| complex(kind=dp), | intent(out) | :: | work(*) | |||
| real(kind=dp), | intent(out) | :: | rwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
HESV computes the solution to a complex system of linear equations A * X = B, where A is an N-by-N Hermitian matrix and X and B are N-by-NRHS matrices. The diagonal pivoting method is used to factor A as A = U * D * UH, if UPLO = 'U', or A = L * D * LH, if UPLO = 'L', where U (or L) is a product of permutation and unit upper (lower) triangular matrices, and D is Hermitian and block diagonal with 1-by-1 and 2-by-2 diagonal blocks. The factored form of A is then used to solve the system of equations A * X = B.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| complex(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| integer(kind=ilp), | intent(out) | :: | ipiv(*) | |||
| complex(kind=sp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| complex(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| complex(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| integer(kind=ilp), | intent(out) | :: | ipiv(*) | |||
| complex(kind=dp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| complex(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
CHESV computes the solution to a complex system of linear equations A * X = B, where A is an N-by-N Hermitian matrix and X and B are N-by-NRHS matrices. The diagonal pivoting method is used to factor A as A = U * D * UH, if UPLO = 'U', or A = L * D * LH, if UPLO = 'L', where U (or L) is a product of permutation and unit upper (lower) triangular matrices, and D is Hermitian and block diagonal with 1-by-1 and 2-by-2 diagonal blocks. The factored form of A is then used to solve the system of equations A * X = B.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| complex(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| integer(kind=ilp), | intent(out) | :: | ipiv(*) | |||
| complex(kind=sp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| complex(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
ZHESV computes the solution to a complex system of linear equations A * X = B, where A is an N-by-N Hermitian matrix and X and B are N-by-NRHS matrices. The diagonal pivoting method is used to factor A as A = U * D * UH, if UPLO = 'U', or A = L * D * LH, if UPLO = 'L', where U (or L) is a product of permutation and unit upper (lower) triangular matrices, and D is Hermitian and block diagonal with 1-by-1 and 2-by-2 diagonal blocks. The factored form of A is then used to solve the system of equations A * X = B.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| complex(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| integer(kind=ilp), | intent(out) | :: | ipiv(*) | |||
| complex(kind=dp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| complex(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
HESV_AA computes the solution to a complex system of linear equations A * X = B, where A is an N-by-N Hermitian matrix and X and B are N-by-NRHS matrices. Aasen's algorithm is used to factor A as A = UH * T * U, if UPLO = 'U', or A = L * T * LH, if UPLO = 'L', where U (or L) is a product of permutation and unit upper (lower) triangular matrices, and T is Hermitian and tridiagonal. The factored form of A is then used to solve the system of equations A * X = B.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| complex(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| integer(kind=ilp), | intent(out) | :: | ipiv(*) | |||
| complex(kind=sp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| complex(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| complex(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| integer(kind=ilp), | intent(out) | :: | ipiv(*) | |||
| complex(kind=dp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| complex(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
CHESV_AA computes the solution to a complex system of linear equations A * X = B, where A is an N-by-N Hermitian matrix and X and B are N-by-NRHS matrices. Aasen's algorithm is used to factor A as A = UH * T * U, if UPLO = 'U', or A = L * T * LH, if UPLO = 'L', where U (or L) is a product of permutation and unit upper (lower) triangular matrices, and T is Hermitian and tridiagonal. The factored form of A is then used to solve the system of equations A * X = B.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| complex(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| integer(kind=ilp), | intent(out) | :: | ipiv(*) | |||
| complex(kind=sp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| complex(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
ZHESV_AA computes the solution to a complex system of linear equations A * X = B, where A is an N-by-N Hermitian matrix and X and B are N-by-NRHS matrices. Aasen's algorithm is used to factor A as A = UH * T * U, if UPLO = 'U', or A = L * T * LH, if UPLO = 'L', where U (or L) is a product of permutation and unit upper (lower) triangular matrices, and T is Hermitian and tridiagonal. The factored form of A is then used to solve the system of equations A * X = B.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| complex(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| integer(kind=ilp), | intent(out) | :: | ipiv(*) | |||
| complex(kind=dp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| complex(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
HESV_RK computes the solution to a complex system of linear equations A * X = B, where A is an N-by-N Hermitian matrix and X and B are N-by-NRHS matrices. The bounded Bunch-Kaufman (rook) diagonal pivoting method is used to factor A as A = PUD(UH)(PT), if UPLO = 'U', or A = PLD*(LH)(PT), if UPLO = 'L', where U (or L) is unit upper (or lower) triangular matrix, UH (or LH) is the conjugate of U (or L), P is a permutation matrix, P*T is the transpose of P, and D is Hermitian and block diagonal with 1-by-1 and 2-by-2 diagonal blocks. CHETRF_RK is called to compute the factorization of a complex Hermitian matrix. The factored form of A is then used to solve the system of equations A * X = B by calling BLAS3 routine CHETRS_3.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| complex(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=sp), | intent(out) | :: | e(*) | |||
| integer(kind=ilp), | intent(out) | :: | ipiv(*) | |||
| complex(kind=sp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| complex(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| complex(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=dp), | intent(out) | :: | e(*) | |||
| integer(kind=ilp), | intent(out) | :: | ipiv(*) | |||
| complex(kind=dp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| complex(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
CHESV_RK computes the solution to a complex system of linear equations A * X = B, where A is an N-by-N Hermitian matrix and X and B are N-by-NRHS matrices. The bounded Bunch-Kaufman (rook) diagonal pivoting method is used to factor A as A = PUD(UH)(PT), if UPLO = 'U', or A = PLD*(LH)(PT), if UPLO = 'L', where U (or L) is unit upper (or lower) triangular matrix, UH (or LH) is the conjugate of U (or L), P is a permutation matrix, P*T is the transpose of P, and D is Hermitian and block diagonal with 1-by-1 and 2-by-2 diagonal blocks. CHETRF_RK is called to compute the factorization of a complex Hermitian matrix. The factored form of A is then used to solve the system of equations A * X = B by calling BLAS3 routine CHETRS_3.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| complex(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=sp), | intent(out) | :: | e(*) | |||
| integer(kind=ilp), | intent(out) | :: | ipiv(*) | |||
| complex(kind=sp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| complex(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
ZHESV_RK computes the solution to a complex system of linear equations A * X = B, where A is an N-by-N Hermitian matrix and X and B are N-by-NRHS matrices. The bounded Bunch-Kaufman (rook) diagonal pivoting method is used to factor A as A = PUD(UH)(PT), if UPLO = 'U', or A = PLD*(LH)(PT), if UPLO = 'L', where U (or L) is unit upper (or lower) triangular matrix, UH (or LH) is the conjugate of U (or L), P is a permutation matrix, P*T is the transpose of P, and D is Hermitian and block diagonal with 1-by-1 and 2-by-2 diagonal blocks. ZHETRF_RK is called to compute the factorization of a complex Hermitian matrix. The factored form of A is then used to solve the system of equations A * X = B by calling BLAS3 routine ZHETRS_3.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| complex(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=dp), | intent(out) | :: | e(*) | |||
| integer(kind=ilp), | intent(out) | :: | ipiv(*) | |||
| complex(kind=dp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| complex(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
HESV_ROOK computes the solution to a complex system of linear equations A * X = B, where A is an N-by-N Hermitian matrix and X and B are N-by-NRHS matrices. The bounded Bunch-Kaufman ("rook") diagonal pivoting method is used to factor A as A = U * D * UT, if UPLO = 'U', or A = L * D * LT, if UPLO = 'L', where U (or L) is a product of permutation and unit upper (lower) triangular matrices, and D is Hermitian and block diagonal with 1-by-1 and 2-by-2 diagonal blocks. CHETRF_ROOK is called to compute the factorization of a complex Hermition matrix A using the bounded Bunch-Kaufman ("rook") diagonal pivoting method. The factored form of A is then used to solve the system of equations A * X = B by calling CHETRS_ROOK (uses BLAS 2).
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| complex(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| integer(kind=ilp), | intent(out) | :: | ipiv(*) | |||
| complex(kind=sp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| complex(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| complex(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| integer(kind=ilp), | intent(out) | :: | ipiv(*) | |||
| complex(kind=dp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| complex(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
CHESV_ROOK computes the solution to a complex system of linear equations A * X = B, where A is an N-by-N Hermitian matrix and X and B are N-by-NRHS matrices. The bounded Bunch-Kaufman ("rook") diagonal pivoting method is used to factor A as A = U * D * UT, if UPLO = 'U', or A = L * D * LT, if UPLO = 'L', where U (or L) is a product of permutation and unit upper (lower) triangular matrices, and D is Hermitian and block diagonal with 1-by-1 and 2-by-2 diagonal blocks. CHETRF_ROOK is called to compute the factorization of a complex Hermition matrix A using the bounded Bunch-Kaufman ("rook") diagonal pivoting method. The factored form of A is then used to solve the system of equations A * X = B by calling CHETRS_ROOK (uses BLAS 2).
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| complex(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| integer(kind=ilp), | intent(out) | :: | ipiv(*) | |||
| complex(kind=sp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| complex(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
ZHESV_ROOK computes the solution to a complex system of linear equations A * X = B, where A is an N-by-N Hermitian matrix and X and B are N-by-NRHS matrices. The bounded Bunch-Kaufman ("rook") diagonal pivoting method is used to factor A as A = U * D * UT, if UPLO = 'U', or A = L * D * LT, if UPLO = 'L', where U (or L) is a product of permutation and unit upper (lower) triangular matrices, and D is Hermitian and block diagonal with 1-by-1 and 2-by-2 diagonal blocks. ZHETRF_ROOK is called to compute the factorization of a complex Hermition matrix A using the bounded Bunch-Kaufman ("rook") diagonal pivoting method. The factored form of A is then used to solve the system of equations A * X = B by calling ZHETRS_ROOK (uses BLAS 2).
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| complex(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| integer(kind=ilp), | intent(out) | :: | ipiv(*) | |||
| complex(kind=dp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| complex(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
HESWAPR applies an elementary permutation on the rows and the columns of a hermitian matrix.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=sp), | intent(inout) | :: | a(lda,n) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| integer(kind=ilp), | intent(in) | :: | i1 | |||
| integer(kind=ilp), | intent(in) | :: | i2 |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=dp), | intent(inout) | :: | a(lda,n) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| integer(kind=ilp), | intent(in) | :: | i1 | |||
| integer(kind=ilp), | intent(in) | :: | i2 |
CHESWAPR applies an elementary permutation on the rows and the columns of a hermitian matrix.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=sp), | intent(inout) | :: | a(lda,n) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| integer(kind=ilp), | intent(in) | :: | i1 | |||
| integer(kind=ilp), | intent(in) | :: | i2 |
ZHESWAPR applies an elementary permutation on the rows and the columns of a hermitian matrix.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=dp), | intent(inout) | :: | a(lda,n) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| integer(kind=ilp), | intent(in) | :: | i1 | |||
| integer(kind=ilp), | intent(in) | :: | i2 |
HETF2_RK computes the factorization of a complex Hermitian matrix A using the bounded Bunch-Kaufman (rook) diagonal pivoting method: A = PUD(UH)(PT) or A = PLD*(LH)(PT), where U (or L) is unit upper (or lower) triangular matrix, UH (or LH) is the conjugate of U (or L), P is a permutation matrix, P*T is the transpose of P, and D is Hermitian and block diagonal with 1-by-1 and 2-by-2 diagonal blocks. This is the unblocked version of the algorithm, calling Level 2 BLAS. For more information see Further Details section.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=sp), | intent(out) | :: | e(*) | |||
| integer(kind=ilp), | intent(out) | :: | ipiv(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=dp), | intent(out) | :: | e(*) | |||
| integer(kind=ilp), | intent(out) | :: | ipiv(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
CHETF2_RK computes the factorization of a complex Hermitian matrix A using the bounded Bunch-Kaufman (rook) diagonal pivoting method: A = PUD(UH)(PT) or A = PLD*(LH)(PT), where U (or L) is unit upper (or lower) triangular matrix, UH (or LH) is the conjugate of U (or L), P is a permutation matrix, P*T is the transpose of P, and D is Hermitian and block diagonal with 1-by-1 and 2-by-2 diagonal blocks. This is the unblocked version of the algorithm, calling Level 2 BLAS. For more information see Further Details section.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=sp), | intent(out) | :: | e(*) | |||
| integer(kind=ilp), | intent(out) | :: | ipiv(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
ZHETF2_RK computes the factorization of a complex Hermitian matrix A using the bounded Bunch-Kaufman (rook) diagonal pivoting method: A = PUD(UH)(PT) or A = PLD*(LH)(PT), where U (or L) is unit upper (or lower) triangular matrix, UH (or LH) is the conjugate of U (or L), P is a permutation matrix, P*T is the transpose of P, and D is Hermitian and block diagonal with 1-by-1 and 2-by-2 diagonal blocks. This is the unblocked version of the algorithm, calling Level 2 BLAS. For more information see Further Details section.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=dp), | intent(out) | :: | e(*) | |||
| integer(kind=ilp), | intent(out) | :: | ipiv(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
HETF2_ROOK computes the factorization of a complex Hermitian matrix A using the bounded Bunch-Kaufman ("rook") diagonal pivoting method: A = UDUH or A = LDLH where U (or L) is a product of permutation and unit upper (lower) triangular matrices, U**H is the conjugate transpose of U, and D is Hermitian and block diagonal with 1-by-1 and 2-by-2 diagonal blocks. This is the unblocked version of the algorithm, calling Level 2 BLAS.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| integer(kind=ilp), | intent(out) | :: | ipiv(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| integer(kind=ilp), | intent(out) | :: | ipiv(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
CHETF2_ROOK computes the factorization of a complex Hermitian matrix A using the bounded Bunch-Kaufman ("rook") diagonal pivoting method: A = UDUH or A = LDLH where U (or L) is a product of permutation and unit upper (lower) triangular matrices, U**H is the conjugate transpose of U, and D is Hermitian and block diagonal with 1-by-1 and 2-by-2 diagonal blocks. This is the unblocked version of the algorithm, calling Level 2 BLAS.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| integer(kind=ilp), | intent(out) | :: | ipiv(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
ZHETF2_ROOK computes the factorization of a complex Hermitian matrix A using the bounded Bunch-Kaufman ("rook") diagonal pivoting method: A = UDUH or A = LDLH where U (or L) is a product of permutation and unit upper (lower) triangular matrices, U**H is the conjugate transpose of U, and D is Hermitian and block diagonal with 1-by-1 and 2-by-2 diagonal blocks. This is the unblocked version of the algorithm, calling Level 2 BLAS.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| integer(kind=ilp), | intent(out) | :: | ipiv(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
HETRD reduces a complex Hermitian matrix A to real symmetric tridiagonal form T by a unitary similarity transformation: Q**H * A * Q = T.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=sp), | intent(out) | :: | d(*) | |||
| real(kind=sp), | intent(out) | :: | e(*) | |||
| complex(kind=sp), | intent(out) | :: | tau(*) | |||
| complex(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=dp), | intent(out) | :: | d(*) | |||
| real(kind=dp), | intent(out) | :: | e(*) | |||
| complex(kind=dp), | intent(out) | :: | tau(*) | |||
| complex(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
CHETRD reduces a complex Hermitian matrix A to real symmetric tridiagonal form T by a unitary similarity transformation: Q**H * A * Q = T.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=sp), | intent(out) | :: | d(*) | |||
| real(kind=sp), | intent(out) | :: | e(*) | |||
| complex(kind=sp), | intent(out) | :: | tau(*) | |||
| complex(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
ZHETRD reduces a complex Hermitian matrix A to real symmetric tridiagonal form T by a unitary similarity transformation: Q**H * A * Q = T.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=dp), | intent(out) | :: | d(*) | |||
| real(kind=dp), | intent(out) | :: | e(*) | |||
| complex(kind=dp), | intent(out) | :: | tau(*) | |||
| complex(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
HETRD_HB2ST reduces a complex Hermitian band matrix A to real symmetric tridiagonal form T by a unitary similarity transformation: Q**H * A * Q = T.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | stage1 | |||
| character, | intent(in) | :: | vect | |||
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | kd | |||
| complex(kind=sp), | intent(inout) | :: | ab(ldab,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldab | |||
| real(kind=sp), | intent(out) | :: | d(*) | |||
| real(kind=sp), | intent(out) | :: | e(*) | |||
| complex(kind=sp), | intent(out) | :: | hous(*) | |||
| integer(kind=ilp), | intent(in) | :: | lhous | |||
| complex(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | stage1 | |||
| character, | intent(in) | :: | vect | |||
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | kd | |||
| complex(kind=dp), | intent(inout) | :: | ab(ldab,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldab | |||
| real(kind=dp), | intent(out) | :: | d(*) | |||
| real(kind=dp), | intent(out) | :: | e(*) | |||
| complex(kind=dp), | intent(out) | :: | hous(*) | |||
| integer(kind=ilp), | intent(in) | :: | lhous | |||
| complex(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
CHETRD_HB2ST reduces a complex Hermitian band matrix A to real symmetric tridiagonal form T by a unitary similarity transformation: Q**H * A * Q = T.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | stage1 | |||
| character, | intent(in) | :: | vect | |||
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | kd | |||
| complex(kind=sp), | intent(inout) | :: | ab(ldab,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldab | |||
| real(kind=sp), | intent(out) | :: | d(*) | |||
| real(kind=sp), | intent(out) | :: | e(*) | |||
| complex(kind=sp), | intent(out) | :: | hous(*) | |||
| integer(kind=ilp), | intent(in) | :: | lhous | |||
| complex(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
ZHETRD_HB2ST reduces a complex Hermitian band matrix A to real symmetric tridiagonal form T by a unitary similarity transformation: Q**H * A * Q = T.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | stage1 | |||
| character, | intent(in) | :: | vect | |||
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | kd | |||
| complex(kind=dp), | intent(inout) | :: | ab(ldab,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldab | |||
| real(kind=dp), | intent(out) | :: | d(*) | |||
| real(kind=dp), | intent(out) | :: | e(*) | |||
| complex(kind=dp), | intent(out) | :: | hous(*) | |||
| integer(kind=ilp), | intent(in) | :: | lhous | |||
| complex(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
HETRD_HE2HB reduces a complex Hermitian matrix A to complex Hermitian band-diagonal form AB by a unitary similarity transformation: Q**H * A * Q = AB.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | kd | |||
| complex(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=sp), | intent(out) | :: | ab(ldab,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldab | |||
| complex(kind=sp), | intent(out) | :: | tau(*) | |||
| complex(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | kd | |||
| complex(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=dp), | intent(out) | :: | ab(ldab,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldab | |||
| complex(kind=dp), | intent(out) | :: | tau(*) | |||
| complex(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
CHETRD_HE2HB reduces a complex Hermitian matrix A to complex Hermitian band-diagonal form AB by a unitary similarity transformation: Q**H * A * Q = AB.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | kd | |||
| complex(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=sp), | intent(out) | :: | ab(ldab,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldab | |||
| complex(kind=sp), | intent(out) | :: | tau(*) | |||
| complex(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
ZHETRD_HE2HB reduces a complex Hermitian matrix A to complex Hermitian band-diagonal form AB by a unitary similarity transformation: Q**H * A * Q = AB.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | kd | |||
| complex(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=dp), | intent(out) | :: | ab(ldab,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldab | |||
| complex(kind=dp), | intent(out) | :: | tau(*) | |||
| complex(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
HETRF computes the factorization of a complex Hermitian matrix A using the Bunch-Kaufman diagonal pivoting method. The form of the factorization is A = UDUH or A = LDLH where U (or L) is a product of permutation and unit upper (lower) triangular matrices, and D is Hermitian and block diagonal with 1-by-1 and 2-by-2 diagonal blocks. This is the blocked version of the algorithm, calling Level 3 BLAS.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| integer(kind=ilp), | intent(out) | :: | ipiv(*) | |||
| complex(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| integer(kind=ilp), | intent(out) | :: | ipiv(*) | |||
| complex(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
CHETRF computes the factorization of a complex Hermitian matrix A using the Bunch-Kaufman diagonal pivoting method. The form of the factorization is A = UDUH or A = LDLH where U (or L) is a product of permutation and unit upper (lower) triangular matrices, and D is Hermitian and block diagonal with 1-by-1 and 2-by-2 diagonal blocks. This is the blocked version of the algorithm, calling Level 3 BLAS.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| integer(kind=ilp), | intent(out) | :: | ipiv(*) | |||
| complex(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
ZHETRF computes the factorization of a complex Hermitian matrix A using the Bunch-Kaufman diagonal pivoting method. The form of the factorization is A = UDUH or A = LDLH where U (or L) is a product of permutation and unit upper (lower) triangular matrices, and D is Hermitian and block diagonal with 1-by-1 and 2-by-2 diagonal blocks. This is the blocked version of the algorithm, calling Level 3 BLAS.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| integer(kind=ilp), | intent(out) | :: | ipiv(*) | |||
| complex(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
HETRF_AA computes the factorization of a complex hermitian matrix A using the Aasen's algorithm. The form of the factorization is A = UHTU or A = LTLH where U (or L) is a product of permutation and unit upper (lower) triangular matrices, and T is a hermitian tridiagonal matrix. This is the blocked version of the algorithm, calling Level 3 BLAS.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| integer(kind=ilp), | intent(out) | :: | ipiv(*) | |||
| complex(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| integer(kind=ilp), | intent(out) | :: | ipiv(*) | |||
| complex(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
CHETRF_AA computes the factorization of a complex hermitian matrix A using the Aasen's algorithm. The form of the factorization is A = UHTU or A = LTLH where U (or L) is a product of permutation and unit upper (lower) triangular matrices, and T is a hermitian tridiagonal matrix. This is the blocked version of the algorithm, calling Level 3 BLAS.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| integer(kind=ilp), | intent(out) | :: | ipiv(*) | |||
| complex(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
ZHETRF_AA computes the factorization of a complex hermitian matrix A using the Aasen's algorithm. The form of the factorization is A = UHTU or A = LTLH where U (or L) is a product of permutation and unit upper (lower) triangular matrices, and T is a hermitian tridiagonal matrix. This is the blocked version of the algorithm, calling Level 3 BLAS.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| integer(kind=ilp), | intent(out) | :: | ipiv(*) | |||
| complex(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
HETRF_RK computes the factorization of a complex Hermitian matrix A using the bounded Bunch-Kaufman (rook) diagonal pivoting method: A = PUD(UH)(PT) or A = PLD*(LH)(PT), where U (or L) is unit upper (or lower) triangular matrix, UH (or LH) is the conjugate of U (or L), P is a permutation matrix, P*T is the transpose of P, and D is Hermitian and block diagonal with 1-by-1 and 2-by-2 diagonal blocks. This is the blocked version of the algorithm, calling Level 3 BLAS. For more information see Further Details section.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=sp), | intent(out) | :: | e(*) | |||
| integer(kind=ilp), | intent(out) | :: | ipiv(*) | |||
| complex(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=dp), | intent(out) | :: | e(*) | |||
| integer(kind=ilp), | intent(out) | :: | ipiv(*) | |||
| complex(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
CHETRF_RK computes the factorization of a complex Hermitian matrix A using the bounded Bunch-Kaufman (rook) diagonal pivoting method: A = PUD(UH)(PT) or A = PLD*(LH)(PT), where U (or L) is unit upper (or lower) triangular matrix, UH (or LH) is the conjugate of U (or L), P is a permutation matrix, P*T is the transpose of P, and D is Hermitian and block diagonal with 1-by-1 and 2-by-2 diagonal blocks. This is the blocked version of the algorithm, calling Level 3 BLAS. For more information see Further Details section.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=sp), | intent(out) | :: | e(*) | |||
| integer(kind=ilp), | intent(out) | :: | ipiv(*) | |||
| complex(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
ZHETRF_RK computes the factorization of a complex Hermitian matrix A using the bounded Bunch-Kaufman (rook) diagonal pivoting method: A = PUD(UH)(PT) or A = PLD*(LH)(PT), where U (or L) is unit upper (or lower) triangular matrix, UH (or LH) is the conjugate of U (or L), P is a permutation matrix, P*T is the transpose of P, and D is Hermitian and block diagonal with 1-by-1 and 2-by-2 diagonal blocks. This is the blocked version of the algorithm, calling Level 3 BLAS. For more information see Further Details section.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=dp), | intent(out) | :: | e(*) | |||
| integer(kind=ilp), | intent(out) | :: | ipiv(*) | |||
| complex(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
HETRF_ROOK computes the factorization of a complex Hermitian matrix A using the bounded Bunch-Kaufman ("rook") diagonal pivoting method. The form of the factorization is A = UDUT or A = LDLT where U (or L) is a product of permutation and unit upper (lower) triangular matrices, and D is Hermitian and block diagonal with 1-by-1 and 2-by-2 diagonal blocks. This is the blocked version of the algorithm, calling Level 3 BLAS.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| integer(kind=ilp), | intent(out) | :: | ipiv(*) | |||
| complex(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| integer(kind=ilp), | intent(out) | :: | ipiv(*) | |||
| complex(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
CHETRF_ROOK computes the factorization of a complex Hermitian matrix A using the bounded Bunch-Kaufman ("rook") diagonal pivoting method. The form of the factorization is A = UDUT or A = LDLT where U (or L) is a product of permutation and unit upper (lower) triangular matrices, and D is Hermitian and block diagonal with 1-by-1 and 2-by-2 diagonal blocks. This is the blocked version of the algorithm, calling Level 3 BLAS.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| integer(kind=ilp), | intent(out) | :: | ipiv(*) | |||
| complex(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
ZHETRF_ROOK computes the factorization of a complex Hermitian matrix A using the bounded Bunch-Kaufman ("rook") diagonal pivoting method. The form of the factorization is A = UDUT or A = LDLT where U (or L) is a product of permutation and unit upper (lower) triangular matrices, and D is Hermitian and block diagonal with 1-by-1 and 2-by-2 diagonal blocks. This is the blocked version of the algorithm, calling Level 3 BLAS.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| integer(kind=ilp), | intent(out) | :: | ipiv(*) | |||
| complex(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
HETRI computes the inverse of a complex Hermitian indefinite matrix A using the factorization A = UDUH or A = LDLH computed by CHETRF.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| integer(kind=ilp), | intent(in) | :: | ipiv(*) | |||
| complex(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| integer(kind=ilp), | intent(in) | :: | ipiv(*) | |||
| complex(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
CHETRI computes the inverse of a complex Hermitian indefinite matrix A using the factorization A = UDUH or A = LDLH computed by CHETRF.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| integer(kind=ilp), | intent(in) | :: | ipiv(*) | |||
| complex(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
ZHETRI computes the inverse of a complex Hermitian indefinite matrix A using the factorization A = UDUH or A = LDLH computed by ZHETRF.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| integer(kind=ilp), | intent(in) | :: | ipiv(*) | |||
| complex(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
HETRI_ROOK computes the inverse of a complex Hermitian indefinite matrix A using the factorization A = UDUH or A = LDLH computed by CHETRF_ROOK.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| integer(kind=ilp), | intent(in) | :: | ipiv(*) | |||
| complex(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| integer(kind=ilp), | intent(in) | :: | ipiv(*) | |||
| complex(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
CHETRI_ROOK computes the inverse of a complex Hermitian indefinite matrix A using the factorization A = UDUH or A = LDLH computed by CHETRF_ROOK.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| integer(kind=ilp), | intent(in) | :: | ipiv(*) | |||
| complex(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
ZHETRI_ROOK computes the inverse of a complex Hermitian indefinite matrix A using the factorization A = UDUH or A = LDLH computed by ZHETRF_ROOK.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| integer(kind=ilp), | intent(in) | :: | ipiv(*) | |||
| complex(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
HETRS solves a system of linear equations AX = B with a complex Hermitian matrix A using the factorization A = UDUH or A = LDL*H computed by CHETRF.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| complex(kind=sp), | intent(in) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| integer(kind=ilp), | intent(in) | :: | ipiv(*) | |||
| complex(kind=sp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| complex(kind=dp), | intent(in) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| integer(kind=ilp), | intent(in) | :: | ipiv(*) | |||
| complex(kind=dp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| integer(kind=ilp), | intent(out) | :: | info |
CHETRS solves a system of linear equations AX = B with a complex Hermitian matrix A using the factorization A = UDUH or A = LDL*H computed by CHETRF.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| complex(kind=sp), | intent(in) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| integer(kind=ilp), | intent(in) | :: | ipiv(*) | |||
| complex(kind=sp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| integer(kind=ilp), | intent(out) | :: | info |
ZHETRS solves a system of linear equations AX = B with a complex Hermitian matrix A using the factorization A = UDUH or A = LDL*H computed by ZHETRF.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| complex(kind=dp), | intent(in) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| integer(kind=ilp), | intent(in) | :: | ipiv(*) | |||
| complex(kind=dp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| integer(kind=ilp), | intent(out) | :: | info |
HETRS2 solves a system of linear equations AX = B with a complex Hermitian matrix A using the factorization A = UDUH or A = LDL*H computed by CHETRF and converted by CSYCONV.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| complex(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| integer(kind=ilp), | intent(in) | :: | ipiv(*) | |||
| complex(kind=sp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| complex(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| complex(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| integer(kind=ilp), | intent(in) | :: | ipiv(*) | |||
| complex(kind=dp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| complex(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
CHETRS2 solves a system of linear equations AX = B with a complex Hermitian matrix A using the factorization A = UDUH or A = LDL*H computed by CHETRF and converted by CSYCONV.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| complex(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| integer(kind=ilp), | intent(in) | :: | ipiv(*) | |||
| complex(kind=sp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| complex(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
ZHETRS2 solves a system of linear equations AX = B with a complex Hermitian matrix A using the factorization A = UDUH or A = LDL*H computed by ZHETRF and converted by ZSYCONV.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| complex(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| integer(kind=ilp), | intent(in) | :: | ipiv(*) | |||
| complex(kind=dp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| complex(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
HETRS_3 solves a system of linear equations A * X = B with a complex Hermitian matrix A using the factorization computed by CHETRF_RK or CHETRF_BK: A = PUD(UH)(PT) or A = PLD*(LH)(PT), where U (or L) is unit upper (or lower) triangular matrix, UH (or LH) is the conjugate of U (or L), P is a permutation matrix, P*T is the transpose of P, and D is Hermitian and block diagonal with 1-by-1 and 2-by-2 diagonal blocks. This algorithm is using Level 3 BLAS.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| complex(kind=sp), | intent(in) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=sp), | intent(in) | :: | e(*) | |||
| integer(kind=ilp), | intent(in) | :: | ipiv(*) | |||
| complex(kind=sp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| complex(kind=dp), | intent(in) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=dp), | intent(in) | :: | e(*) | |||
| integer(kind=ilp), | intent(in) | :: | ipiv(*) | |||
| complex(kind=dp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| integer(kind=ilp), | intent(out) | :: | info |
CHETRS_3 solves a system of linear equations A * X = B with a complex Hermitian matrix A using the factorization computed by CHETRF_RK or CHETRF_BK: A = PUD(UH)(PT) or A = PLD*(LH)(PT), where U (or L) is unit upper (or lower) triangular matrix, UH (or LH) is the conjugate of U (or L), P is a permutation matrix, P*T is the transpose of P, and D is Hermitian and block diagonal with 1-by-1 and 2-by-2 diagonal blocks. This algorithm is using Level 3 BLAS.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| complex(kind=sp), | intent(in) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=sp), | intent(in) | :: | e(*) | |||
| integer(kind=ilp), | intent(in) | :: | ipiv(*) | |||
| complex(kind=sp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| integer(kind=ilp), | intent(out) | :: | info |
ZHETRS_3 solves a system of linear equations A * X = B with a complex Hermitian matrix A using the factorization computed by ZHETRF_RK or ZHETRF_BK: A = PUD(UH)(PT) or A = PLD*(LH)(PT), where U (or L) is unit upper (or lower) triangular matrix, UH (or LH) is the conjugate of U (or L), P is a permutation matrix, P*T is the transpose of P, and D is Hermitian and block diagonal with 1-by-1 and 2-by-2 diagonal blocks. This algorithm is using Level 3 BLAS.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| complex(kind=dp), | intent(in) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=dp), | intent(in) | :: | e(*) | |||
| integer(kind=ilp), | intent(in) | :: | ipiv(*) | |||
| complex(kind=dp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| integer(kind=ilp), | intent(out) | :: | info |
HETRS_AA solves a system of linear equations AX = B with a complex hermitian matrix A using the factorization A = UHTU or A = LTL*H computed by CHETRF_AA.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| complex(kind=sp), | intent(in) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| integer(kind=ilp), | intent(in) | :: | ipiv(*) | |||
| complex(kind=sp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| complex(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| complex(kind=dp), | intent(in) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| integer(kind=ilp), | intent(in) | :: | ipiv(*) | |||
| complex(kind=dp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| complex(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
CHETRS_AA solves a system of linear equations AX = B with a complex hermitian matrix A using the factorization A = UHTU or A = LTL*H computed by CHETRF_AA.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| complex(kind=sp), | intent(in) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| integer(kind=ilp), | intent(in) | :: | ipiv(*) | |||
| complex(kind=sp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| complex(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
ZHETRS_AA solves a system of linear equations AX = B with a complex hermitian matrix A using the factorization A = UHTU or A = LTL*H computed by ZHETRF_AA.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| complex(kind=dp), | intent(in) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| integer(kind=ilp), | intent(in) | :: | ipiv(*) | |||
| complex(kind=dp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| complex(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
HETRS_ROOK solves a system of linear equations AX = B with a complex Hermitian matrix A using the factorization A = UDUH or A = LDL*H computed by CHETRF_ROOK.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| complex(kind=sp), | intent(in) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| integer(kind=ilp), | intent(in) | :: | ipiv(*) | |||
| complex(kind=sp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| complex(kind=dp), | intent(in) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| integer(kind=ilp), | intent(in) | :: | ipiv(*) | |||
| complex(kind=dp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| integer(kind=ilp), | intent(out) | :: | info |
CHETRS_ROOK solves a system of linear equations AX = B with a complex Hermitian matrix A using the factorization A = UDUH or A = LDL*H computed by CHETRF_ROOK.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| complex(kind=sp), | intent(in) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| integer(kind=ilp), | intent(in) | :: | ipiv(*) | |||
| complex(kind=sp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| integer(kind=ilp), | intent(out) | :: | info |
ZHETRS_ROOK solves a system of linear equations AX = B with a complex Hermitian matrix A using the factorization A = UDUH or A = LDL*H computed by ZHETRF_ROOK.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| complex(kind=dp), | intent(in) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| integer(kind=ilp), | intent(in) | :: | ipiv(*) | |||
| complex(kind=dp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| integer(kind=ilp), | intent(out) | :: | info |
Level 3 BLAS like routine for C in RFP Format. HFRK performs one of the Hermitian rank--k operations C := alphaAAH + betaC, or C := alphaAHA + betaC, where alpha and beta are real scalars, C is an n--by--n Hermitian matrix and A is an n--by--k matrix in the first case and a k--by--n matrix in the second case.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | transr | |||
| character, | intent(in) | :: | uplo | |||
| character, | intent(in) | :: | trans | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | k | |||
| real(kind=sp), | intent(in) | :: | alpha | |||
| complex(kind=sp), | intent(in) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=sp), | intent(in) | :: | beta | |||
| complex(kind=sp), | intent(inout) | :: | c(*) |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | transr | |||
| character, | intent(in) | :: | uplo | |||
| character, | intent(in) | :: | trans | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | k | |||
| real(kind=dp), | intent(in) | :: | alpha | |||
| complex(kind=dp), | intent(in) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=dp), | intent(in) | :: | beta | |||
| complex(kind=dp), | intent(inout) | :: | c(*) |
Level 3 BLAS like routine for C in RFP Format. CHFRK performs one of the Hermitian rank--k operations C := alphaAAH + betaC, or C := alphaAHA + betaC, where alpha and beta are real scalars, C is an n--by--n Hermitian matrix and A is an n--by--k matrix in the first case and a k--by--n matrix in the second case.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | transr | |||
| character, | intent(in) | :: | uplo | |||
| character, | intent(in) | :: | trans | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | k | |||
| real(kind=sp), | intent(in) | :: | alpha | |||
| complex(kind=sp), | intent(in) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=sp), | intent(in) | :: | beta | |||
| complex(kind=sp), | intent(inout) | :: | c(*) |
Level 3 BLAS like routine for C in RFP Format. ZHFRK performs one of the Hermitian rank--k operations C := alphaAAH + betaC, or C := alphaAHA + betaC, where alpha and beta are real scalars, C is an n--by--n Hermitian matrix and A is an n--by--k matrix in the first case and a k--by--n matrix in the second case.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | transr | |||
| character, | intent(in) | :: | uplo | |||
| character, | intent(in) | :: | trans | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | k | |||
| real(kind=dp), | intent(in) | :: | alpha | |||
| complex(kind=dp), | intent(in) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=dp), | intent(in) | :: | beta | |||
| complex(kind=dp), | intent(inout) | :: | c(*) |
HGEQZ computes the eigenvalues of a complex matrix pair (H,T), where H is an upper Hessenberg matrix and T is upper triangular, using the single-shift QZ method. Matrix pairs of this type are produced by the reduction to generalized upper Hessenberg form of a complex matrix pair (A,B): A = Q1HZ1H, B = Q1TZ1H, as computed by CGGHRD. If JOB='S', then the Hessenberg-triangular pair (H,T) is also reduced to generalized Schur form, H = QSZH, T = QPZH, where Q and Z are unitary matrices and S and P are upper triangular. Optionally, the unitary matrix Q from the generalized Schur factorization may be postmultiplied into an input matrix Q1, and the unitary matrix Z may be postmultiplied into an input matrix Z1. If Q1 and Z1 are the unitary matrices from CGGHRD that reduced the matrix pair (A,B) to generalized Hessenberg form, then the output matrices Q1Q and Z1Z are the unitary factors from the generalized Schur factorization of (A,B): A = (Q1Q)S(Z1Z)H, B = (Q1Q)P(Z1Z)H. To avoid overflow, eigenvalues of the matrix pair (H,T) (equivalently, of (A,B)) are computed as a pair of complex values (alpha,beta). If beta is nonzero, lambda = alpha / beta is an eigenvalue of the generalized nonsymmetric eigenvalue problem (GNEP) Ax = lambdaBx and if alpha is nonzero, mu = beta / alpha is an eigenvalue of the alternate form of the GNEP muAy = By. The values of alpha and beta for the i-th eigenvalue can be read directly from the generalized Schur form: alpha = S(i,i), beta = P(i,i). Ref: C.B. Moler Eigenvalue Problems", SIAM J. Numer. Anal., 10(1973), pp. 241--256.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | job | |||
| character, | intent(in) | :: | compq | |||
| character, | intent(in) | :: | compz | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | ilo | |||
| integer(kind=ilp), | intent(in) | :: | ihi | |||
| complex(kind=sp), | intent(inout) | :: | h(ldh,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldh | |||
| complex(kind=sp), | intent(inout) | :: | t(ldt,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldt | |||
| complex(kind=sp), | intent(out) | :: | alpha(*) | |||
| complex(kind=sp), | intent(out) | :: | beta(*) | |||
| complex(kind=sp), | intent(inout) | :: | q(ldq,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldq | |||
| complex(kind=sp), | intent(inout) | :: | z(ldz,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldz | |||
| complex(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| real(kind=sp), | intent(out) | :: | rwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | job | |||
| character, | intent(in) | :: | compq | |||
| character, | intent(in) | :: | compz | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | ilo | |||
| integer(kind=ilp), | intent(in) | :: | ihi | |||
| real(kind=dp), | intent(inout) | :: | h(ldh,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldh | |||
| real(kind=dp), | intent(inout) | :: | t(ldt,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldt | |||
| real(kind=dp), | intent(out) | :: | alphar(*) | |||
| real(kind=dp), | intent(out) | :: | alphai(*) | |||
| real(kind=dp), | intent(out) | :: | beta(*) | |||
| real(kind=dp), | intent(inout) | :: | q(ldq,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldq | |||
| real(kind=dp), | intent(inout) | :: | z(ldz,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldz | |||
| real(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | job | |||
| character, | intent(in) | :: | compq | |||
| character, | intent(in) | :: | compz | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | ilo | |||
| integer(kind=ilp), | intent(in) | :: | ihi | |||
| real(kind=sp), | intent(inout) | :: | h(ldh,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldh | |||
| real(kind=sp), | intent(inout) | :: | t(ldt,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldt | |||
| real(kind=sp), | intent(out) | :: | alphar(*) | |||
| real(kind=sp), | intent(out) | :: | alphai(*) | |||
| real(kind=sp), | intent(out) | :: | beta(*) | |||
| real(kind=sp), | intent(inout) | :: | q(ldq,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldq | |||
| real(kind=sp), | intent(inout) | :: | z(ldz,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldz | |||
| real(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | job | |||
| character, | intent(in) | :: | compq | |||
| character, | intent(in) | :: | compz | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | ilo | |||
| integer(kind=ilp), | intent(in) | :: | ihi | |||
| complex(kind=dp), | intent(inout) | :: | h(ldh,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldh | |||
| complex(kind=dp), | intent(inout) | :: | t(ldt,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldt | |||
| complex(kind=dp), | intent(out) | :: | alpha(*) | |||
| complex(kind=dp), | intent(out) | :: | beta(*) | |||
| complex(kind=dp), | intent(inout) | :: | q(ldq,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldq | |||
| complex(kind=dp), | intent(inout) | :: | z(ldz,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldz | |||
| complex(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| real(kind=dp), | intent(out) | :: | rwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
CHGEQZ computes the eigenvalues of a complex matrix pair (H,T), where H is an upper Hessenberg matrix and T is upper triangular, using the single-shift QZ method. Matrix pairs of this type are produced by the reduction to generalized upper Hessenberg form of a complex matrix pair (A,B): A = Q1HZ1H, B = Q1TZ1H, as computed by CGGHRD. If JOB='S', then the Hessenberg-triangular pair (H,T) is also reduced to generalized Schur form, H = QSZH, T = QPZH, where Q and Z are unitary matrices and S and P are upper triangular. Optionally, the unitary matrix Q from the generalized Schur factorization may be postmultiplied into an input matrix Q1, and the unitary matrix Z may be postmultiplied into an input matrix Z1. If Q1 and Z1 are the unitary matrices from CGGHRD that reduced the matrix pair (A,B) to generalized Hessenberg form, then the output matrices Q1Q and Z1Z are the unitary factors from the generalized Schur factorization of (A,B): A = (Q1Q)S(Z1Z)H, B = (Q1Q)P(Z1Z)H. To avoid overflow, eigenvalues of the matrix pair (H,T) (equivalently, of (A,B)) are computed as a pair of complex values (alpha,beta). If beta is nonzero, lambda = alpha / beta is an eigenvalue of the generalized nonsymmetric eigenvalue problem (GNEP) Ax = lambdaBx and if alpha is nonzero, mu = beta / alpha is an eigenvalue of the alternate form of the GNEP muAy = By. The values of alpha and beta for the i-th eigenvalue can be read directly from the generalized Schur form: alpha = S(i,i), beta = P(i,i). Ref: C.B. Moler Eigenvalue Problems", SIAM J. Numer. Anal., 10(1973), pp. 241--256.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | job | |||
| character, | intent(in) | :: | compq | |||
| character, | intent(in) | :: | compz | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | ilo | |||
| integer(kind=ilp), | intent(in) | :: | ihi | |||
| complex(kind=sp), | intent(inout) | :: | h(ldh,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldh | |||
| complex(kind=sp), | intent(inout) | :: | t(ldt,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldt | |||
| complex(kind=sp), | intent(out) | :: | alpha(*) | |||
| complex(kind=sp), | intent(out) | :: | beta(*) | |||
| complex(kind=sp), | intent(inout) | :: | q(ldq,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldq | |||
| complex(kind=sp), | intent(inout) | :: | z(ldz,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldz | |||
| complex(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| real(kind=sp), | intent(out) | :: | rwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
DHGEQZ computes the eigenvalues of a real matrix pair (H,T), where H is an upper Hessenberg matrix and T is upper triangular, using the double-shift QZ method. Matrix pairs of this type are produced by the reduction to generalized upper Hessenberg form of a real matrix pair (A,B): A = Q1HZ1T, B = Q1TZ1T, as computed by DGGHRD. If JOB='S', then the Hessenberg-triangular pair (H,T) is also reduced to generalized Schur form, H = QSZT, T = QPZT, where Q and Z are orthogonal matrices, P is an upper triangular matrix, and S is a quasi-triangular matrix with 1-by-1 and 2-by-2 diagonal blocks. The 1-by-1 blocks correspond to real eigenvalues of the matrix pair (H,T) and the 2-by-2 blocks correspond to complex conjugate pairs of eigenvalues. Additionally, the 2-by-2 upper triangular diagonal blocks of P corresponding to 2-by-2 blocks of S are reduced to positive diagonal form, i.e., if S(j+1,j) is non-zero, then P(j+1,j) = P(j,j+1) = 0, P(j,j) > 0, and P(j+1,j+1) > 0. Optionally, the orthogonal matrix Q from the generalized Schur factorization may be postmultiplied into an input matrix Q1, and the orthogonal matrix Z may be postmultiplied into an input matrix Z1. If Q1 and Z1 are the orthogonal matrices from DGGHRD that reduced the matrix pair (A,B) to generalized upper Hessenberg form, then the output matrices Q1Q and Z1Z are the orthogonal factors from the generalized Schur factorization of (A,B): A = (Q1Q)S(Z1Z)T, B = (Q1Q)P(Z1Z)T. To avoid overflow, eigenvalues of the matrix pair (H,T) (equivalently, of (A,B)) are computed as a pair of values (alpha,beta), where alpha is complex and beta real. If beta is nonzero, lambda = alpha / beta is an eigenvalue of the generalized nonsymmetric eigenvalue problem (GNEP) Ax = lambdaBx and if alpha is nonzero, mu = beta / alpha is an eigenvalue of the alternate form of the GNEP muAy = By. Real eigenvalues can be read directly from the generalized Schur form: alpha = S(i,i), beta = P(i,i). Ref: C.B. Moler Eigenvalue Problems", SIAM J. Numer. Anal., 10(1973), pp. 241--256.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | job | |||
| character, | intent(in) | :: | compq | |||
| character, | intent(in) | :: | compz | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | ilo | |||
| integer(kind=ilp), | intent(in) | :: | ihi | |||
| real(kind=dp), | intent(inout) | :: | h(ldh,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldh | |||
| real(kind=dp), | intent(inout) | :: | t(ldt,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldt | |||
| real(kind=dp), | intent(out) | :: | alphar(*) | |||
| real(kind=dp), | intent(out) | :: | alphai(*) | |||
| real(kind=dp), | intent(out) | :: | beta(*) | |||
| real(kind=dp), | intent(inout) | :: | q(ldq,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldq | |||
| real(kind=dp), | intent(inout) | :: | z(ldz,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldz | |||
| real(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
SHGEQZ computes the eigenvalues of a real matrix pair (H,T), where H is an upper Hessenberg matrix and T is upper triangular, using the double-shift QZ method. Matrix pairs of this type are produced by the reduction to generalized upper Hessenberg form of a real matrix pair (A,B): A = Q1HZ1T, B = Q1TZ1T, as computed by SGGHRD. If JOB='S', then the Hessenberg-triangular pair (H,T) is also reduced to generalized Schur form, H = QSZT, T = QPZT, where Q and Z are orthogonal matrices, P is an upper triangular matrix, and S is a quasi-triangular matrix with 1-by-1 and 2-by-2 diagonal blocks. The 1-by-1 blocks correspond to real eigenvalues of the matrix pair (H,T) and the 2-by-2 blocks correspond to complex conjugate pairs of eigenvalues. Additionally, the 2-by-2 upper triangular diagonal blocks of P corresponding to 2-by-2 blocks of S are reduced to positive diagonal form, i.e., if S(j+1,j) is non-zero, then P(j+1,j) = P(j,j+1) = 0, P(j,j) > 0, and P(j+1,j+1) > 0. Optionally, the orthogonal matrix Q from the generalized Schur factorization may be postmultiplied into an input matrix Q1, and the orthogonal matrix Z may be postmultiplied into an input matrix Z1. If Q1 and Z1 are the orthogonal matrices from SGGHRD that reduced the matrix pair (A,B) to generalized upper Hessenberg form, then the output matrices Q1Q and Z1Z are the orthogonal factors from the generalized Schur factorization of (A,B): A = (Q1Q)S(Z1Z)T, B = (Q1Q)P(Z1Z)T. To avoid overflow, eigenvalues of the matrix pair (H,T) (equivalently, of (A,B)) are computed as a pair of values (alpha,beta), where alpha is complex and beta real. If beta is nonzero, lambda = alpha / beta is an eigenvalue of the generalized nonsymmetric eigenvalue problem (GNEP) Ax = lambdaBx and if alpha is nonzero, mu = beta / alpha is an eigenvalue of the alternate form of the GNEP muAy = By. Real eigenvalues can be read directly from the generalized Schur form: alpha = S(i,i), beta = P(i,i). Ref: C.B. Moler Eigenvalue Problems", SIAM J. Numer. Anal., 10(1973), pp. 241--256.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | job | |||
| character, | intent(in) | :: | compq | |||
| character, | intent(in) | :: | compz | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | ilo | |||
| integer(kind=ilp), | intent(in) | :: | ihi | |||
| real(kind=sp), | intent(inout) | :: | h(ldh,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldh | |||
| real(kind=sp), | intent(inout) | :: | t(ldt,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldt | |||
| real(kind=sp), | intent(out) | :: | alphar(*) | |||
| real(kind=sp), | intent(out) | :: | alphai(*) | |||
| real(kind=sp), | intent(out) | :: | beta(*) | |||
| real(kind=sp), | intent(inout) | :: | q(ldq,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldq | |||
| real(kind=sp), | intent(inout) | :: | z(ldz,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldz | |||
| real(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
ZHGEQZ computes the eigenvalues of a complex matrix pair (H,T), where H is an upper Hessenberg matrix and T is upper triangular, using the single-shift QZ method. Matrix pairs of this type are produced by the reduction to generalized upper Hessenberg form of a complex matrix pair (A,B): A = Q1HZ1H, B = Q1TZ1H, as computed by ZGGHRD. If JOB='S', then the Hessenberg-triangular pair (H,T) is also reduced to generalized Schur form, H = QSZH, T = QPZH, where Q and Z are unitary matrices and S and P are upper triangular. Optionally, the unitary matrix Q from the generalized Schur factorization may be postmultiplied into an input matrix Q1, and the unitary matrix Z may be postmultiplied into an input matrix Z1. If Q1 and Z1 are the unitary matrices from ZGGHRD that reduced the matrix pair (A,B) to generalized Hessenberg form, then the output matrices Q1Q and Z1Z are the unitary factors from the generalized Schur factorization of (A,B): A = (Q1Q)S(Z1Z)H, B = (Q1Q)P(Z1Z)H. To avoid overflow, eigenvalues of the matrix pair (H,T) (equivalently, of (A,B)) are computed as a pair of complex values (alpha,beta). If beta is nonzero, lambda = alpha / beta is an eigenvalue of the generalized nonsymmetric eigenvalue problem (GNEP) Ax = lambdaBx and if alpha is nonzero, mu = beta / alpha is an eigenvalue of the alternate form of the GNEP muAy = By. The values of alpha and beta for the i-th eigenvalue can be read directly from the generalized Schur form: alpha = S(i,i), beta = P(i,i). Ref: C.B. Moler Eigenvalue Problems", SIAM J. Numer. Anal., 10(1973), pp. 241--256.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | job | |||
| character, | intent(in) | :: | compq | |||
| character, | intent(in) | :: | compz | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | ilo | |||
| integer(kind=ilp), | intent(in) | :: | ihi | |||
| complex(kind=dp), | intent(inout) | :: | h(ldh,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldh | |||
| complex(kind=dp), | intent(inout) | :: | t(ldt,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldt | |||
| complex(kind=dp), | intent(out) | :: | alpha(*) | |||
| complex(kind=dp), | intent(out) | :: | beta(*) | |||
| complex(kind=dp), | intent(inout) | :: | q(ldq,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldq | |||
| complex(kind=dp), | intent(inout) | :: | z(ldz,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldz | |||
| complex(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| real(kind=dp), | intent(out) | :: | rwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
HPCON estimates the reciprocal of the condition number of a complex Hermitian packed matrix A using the factorization A = UDUH or A = LDLH computed by CHPTRF. An estimate is obtained for norm(inv(A)), and the reciprocal of the condition number is computed as RCOND = 1 / (ANORM * norm(inv(A))).
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=sp), | intent(in) | :: | ap(*) | |||
| integer(kind=ilp), | intent(in) | :: | ipiv(*) | |||
| real(kind=sp), | intent(in) | :: | anorm | |||
| real(kind=sp), | intent(out) | :: | rcond | |||
| complex(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=dp), | intent(in) | :: | ap(*) | |||
| integer(kind=ilp), | intent(in) | :: | ipiv(*) | |||
| real(kind=dp), | intent(in) | :: | anorm | |||
| real(kind=dp), | intent(out) | :: | rcond | |||
| complex(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
CHPCON estimates the reciprocal of the condition number of a complex Hermitian packed matrix A using the factorization A = UDUH or A = LDLH computed by CHPTRF. An estimate is obtained for norm(inv(A)), and the reciprocal of the condition number is computed as RCOND = 1 / (ANORM * norm(inv(A))).
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=sp), | intent(in) | :: | ap(*) | |||
| integer(kind=ilp), | intent(in) | :: | ipiv(*) | |||
| real(kind=sp), | intent(in) | :: | anorm | |||
| real(kind=sp), | intent(out) | :: | rcond | |||
| complex(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
ZHPCON estimates the reciprocal of the condition number of a complex Hermitian packed matrix A using the factorization A = UDUH or A = LDLH computed by ZHPTRF. An estimate is obtained for norm(inv(A)), and the reciprocal of the condition number is computed as RCOND = 1 / (ANORM * norm(inv(A))).
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=dp), | intent(in) | :: | ap(*) | |||
| integer(kind=ilp), | intent(in) | :: | ipiv(*) | |||
| real(kind=dp), | intent(in) | :: | anorm | |||
| real(kind=dp), | intent(out) | :: | rcond | |||
| complex(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
HPEV computes all the eigenvalues and, optionally, eigenvectors of a complex Hermitian matrix in packed storage.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | jobz | |||
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=sp), | intent(inout) | :: | ap(*) | |||
| real(kind=sp), | intent(out) | :: | w(*) | |||
| complex(kind=sp), | intent(out) | :: | z(ldz,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldz | |||
| complex(kind=sp), | intent(out) | :: | work(*) | |||
| real(kind=sp), | intent(out) | :: | rwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | jobz | |||
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=dp), | intent(inout) | :: | ap(*) | |||
| real(kind=dp), | intent(out) | :: | w(*) | |||
| complex(kind=dp), | intent(out) | :: | z(ldz,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldz | |||
| complex(kind=dp), | intent(out) | :: | work(*) | |||
| real(kind=dp), | intent(out) | :: | rwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
CHPEV computes all the eigenvalues and, optionally, eigenvectors of a complex Hermitian matrix in packed storage.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | jobz | |||
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=sp), | intent(inout) | :: | ap(*) | |||
| real(kind=sp), | intent(out) | :: | w(*) | |||
| complex(kind=sp), | intent(out) | :: | z(ldz,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldz | |||
| complex(kind=sp), | intent(out) | :: | work(*) | |||
| real(kind=sp), | intent(out) | :: | rwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
ZHPEV computes all the eigenvalues and, optionally, eigenvectors of a complex Hermitian matrix in packed storage.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | jobz | |||
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=dp), | intent(inout) | :: | ap(*) | |||
| real(kind=dp), | intent(out) | :: | w(*) | |||
| complex(kind=dp), | intent(out) | :: | z(ldz,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldz | |||
| complex(kind=dp), | intent(out) | :: | work(*) | |||
| real(kind=dp), | intent(out) | :: | rwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
HPEVD computes all the eigenvalues and, optionally, eigenvectors of a complex Hermitian matrix A in packed storage. If eigenvectors are desired, it uses a divide and conquer algorithm. The divide and conquer algorithm makes very mild assumptions about floating point arithmetic. It will work on machines with a guard digit in add/subtract, or on those binary machines without guard digits which subtract like the Cray X-MP, Cray Y-MP, Cray C-90, or Cray-2. It could conceivably fail on hexadecimal or decimal machines without guard digits, but we know of none.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | jobz | |||
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=sp), | intent(inout) | :: | ap(*) | |||
| real(kind=sp), | intent(out) | :: | w(*) | |||
| complex(kind=sp), | intent(out) | :: | z(ldz,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldz | |||
| complex(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| real(kind=sp), | intent(out) | :: | rwork(*) | |||
| integer(kind=ilp), | intent(in) | :: | lrwork | |||
| integer(kind=ilp), | intent(out) | :: | iwork(*) | |||
| integer(kind=ilp), | intent(in) | :: | liwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | jobz | |||
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=dp), | intent(inout) | :: | ap(*) | |||
| real(kind=dp), | intent(out) | :: | w(*) | |||
| complex(kind=dp), | intent(out) | :: | z(ldz,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldz | |||
| complex(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| real(kind=dp), | intent(out) | :: | rwork(*) | |||
| integer(kind=ilp), | intent(in) | :: | lrwork | |||
| integer(kind=ilp), | intent(out) | :: | iwork(*) | |||
| integer(kind=ilp), | intent(in) | :: | liwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
CHPEVD computes all the eigenvalues and, optionally, eigenvectors of a complex Hermitian matrix A in packed storage. If eigenvectors are desired, it uses a divide and conquer algorithm. The divide and conquer algorithm makes very mild assumptions about floating point arithmetic. It will work on machines with a guard digit in add/subtract, or on those binary machines without guard digits which subtract like the Cray X-MP, Cray Y-MP, Cray C-90, or Cray-2. It could conceivably fail on hexadecimal or decimal machines without guard digits, but we know of none.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | jobz | |||
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=sp), | intent(inout) | :: | ap(*) | |||
| real(kind=sp), | intent(out) | :: | w(*) | |||
| complex(kind=sp), | intent(out) | :: | z(ldz,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldz | |||
| complex(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| real(kind=sp), | intent(out) | :: | rwork(*) | |||
| integer(kind=ilp), | intent(in) | :: | lrwork | |||
| integer(kind=ilp), | intent(out) | :: | iwork(*) | |||
| integer(kind=ilp), | intent(in) | :: | liwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
ZHPEVD computes all the eigenvalues and, optionally, eigenvectors of a complex Hermitian matrix A in packed storage. If eigenvectors are desired, it uses a divide and conquer algorithm. The divide and conquer algorithm makes very mild assumptions about floating point arithmetic. It will work on machines with a guard digit in add/subtract, or on those binary machines without guard digits which subtract like the Cray X-MP, Cray Y-MP, Cray C-90, or Cray-2. It could conceivably fail on hexadecimal or decimal machines without guard digits, but we know of none.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | jobz | |||
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=dp), | intent(inout) | :: | ap(*) | |||
| real(kind=dp), | intent(out) | :: | w(*) | |||
| complex(kind=dp), | intent(out) | :: | z(ldz,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldz | |||
| complex(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| real(kind=dp), | intent(out) | :: | rwork(*) | |||
| integer(kind=ilp), | intent(in) | :: | lrwork | |||
| integer(kind=ilp), | intent(out) | :: | iwork(*) | |||
| integer(kind=ilp), | intent(in) | :: | liwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
HPGST reduces a complex Hermitian-definite generalized eigenproblem to standard form, using packed storage. If ITYPE = 1, the problem is Ax = lambdaBx, and A is overwritten by inv(UH)Ainv(U) or inv(L)Ainv(LH) If ITYPE = 2 or 3, the problem is ABx = lambdax or BAx = lambdax, and A is overwritten by UAUH or LHAL. B must have been previously factorized as UHU or LL*H by CPPTRF.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | itype | |||
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=sp), | intent(inout) | :: | ap(*) | |||
| complex(kind=sp), | intent(in) | :: | bp(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | itype | |||
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=dp), | intent(inout) | :: | ap(*) | |||
| complex(kind=dp), | intent(in) | :: | bp(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
CHPGST reduces a complex Hermitian-definite generalized eigenproblem to standard form, using packed storage. If ITYPE = 1, the problem is Ax = lambdaBx, and A is overwritten by inv(UH)Ainv(U) or inv(L)Ainv(LH) If ITYPE = 2 or 3, the problem is ABx = lambdax or BAx = lambdax, and A is overwritten by UAUH or LHAL. B must have been previously factorized as UHU or LL*H by CPPTRF.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | itype | |||
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=sp), | intent(inout) | :: | ap(*) | |||
| complex(kind=sp), | intent(in) | :: | bp(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
ZHPGST reduces a complex Hermitian-definite generalized eigenproblem to standard form, using packed storage. If ITYPE = 1, the problem is Ax = lambdaBx, and A is overwritten by inv(UH)Ainv(U) or inv(L)Ainv(LH) If ITYPE = 2 or 3, the problem is ABx = lambdax or BAx = lambdax, and A is overwritten by UAUH or LHAL. B must have been previously factorized as UHU or LL*H by ZPPTRF.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | itype | |||
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=dp), | intent(inout) | :: | ap(*) | |||
| complex(kind=dp), | intent(in) | :: | bp(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
HPGV computes all the eigenvalues and, optionally, the eigenvectors of a complex generalized Hermitian-definite eigenproblem, of the form Ax=(lambda)Bx, ABx=(lambda)x, or BAx=(lambda)x. Here A and B are assumed to be Hermitian, stored in packed format, and B is also positive definite.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | itype | |||
| character, | intent(in) | :: | jobz | |||
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=sp), | intent(inout) | :: | ap(*) | |||
| complex(kind=sp), | intent(inout) | :: | bp(*) | |||
| real(kind=sp), | intent(out) | :: | w(*) | |||
| complex(kind=sp), | intent(out) | :: | z(ldz,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldz | |||
| complex(kind=sp), | intent(out) | :: | work(*) | |||
| real(kind=sp), | intent(out) | :: | rwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | itype | |||
| character, | intent(in) | :: | jobz | |||
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=dp), | intent(inout) | :: | ap(*) | |||
| complex(kind=dp), | intent(inout) | :: | bp(*) | |||
| real(kind=dp), | intent(out) | :: | w(*) | |||
| complex(kind=dp), | intent(out) | :: | z(ldz,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldz | |||
| complex(kind=dp), | intent(out) | :: | work(*) | |||
| real(kind=dp), | intent(out) | :: | rwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
CHPGV computes all the eigenvalues and, optionally, the eigenvectors of a complex generalized Hermitian-definite eigenproblem, of the form Ax=(lambda)Bx, ABx=(lambda)x, or BAx=(lambda)x. Here A and B are assumed to be Hermitian, stored in packed format, and B is also positive definite.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | itype | |||
| character, | intent(in) | :: | jobz | |||
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=sp), | intent(inout) | :: | ap(*) | |||
| complex(kind=sp), | intent(inout) | :: | bp(*) | |||
| real(kind=sp), | intent(out) | :: | w(*) | |||
| complex(kind=sp), | intent(out) | :: | z(ldz,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldz | |||
| complex(kind=sp), | intent(out) | :: | work(*) | |||
| real(kind=sp), | intent(out) | :: | rwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
ZHPGV computes all the eigenvalues and, optionally, the eigenvectors of a complex generalized Hermitian-definite eigenproblem, of the form Ax=(lambda)Bx, ABx=(lambda)x, or BAx=(lambda)x. Here A and B are assumed to be Hermitian, stored in packed format, and B is also positive definite.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | itype | |||
| character, | intent(in) | :: | jobz | |||
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=dp), | intent(inout) | :: | ap(*) | |||
| complex(kind=dp), | intent(inout) | :: | bp(*) | |||
| real(kind=dp), | intent(out) | :: | w(*) | |||
| complex(kind=dp), | intent(out) | :: | z(ldz,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldz | |||
| complex(kind=dp), | intent(out) | :: | work(*) | |||
| real(kind=dp), | intent(out) | :: | rwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
HPGVD computes all the eigenvalues and, optionally, the eigenvectors of a complex generalized Hermitian-definite eigenproblem, of the form Ax=(lambda)Bx, ABx=(lambda)x, or BAx=(lambda)x. Here A and B are assumed to be Hermitian, stored in packed format, and B is also positive definite. If eigenvectors are desired, it uses a divide and conquer algorithm. The divide and conquer algorithm makes very mild assumptions about floating point arithmetic. It will work on machines with a guard digit in add/subtract, or on those binary machines without guard digits which subtract like the Cray X-MP, Cray Y-MP, Cray C-90, or Cray-2. It could conceivably fail on hexadecimal or decimal machines without guard digits, but we know of none.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | itype | |||
| character, | intent(in) | :: | jobz | |||
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=sp), | intent(inout) | :: | ap(*) | |||
| complex(kind=sp), | intent(inout) | :: | bp(*) | |||
| real(kind=sp), | intent(out) | :: | w(*) | |||
| complex(kind=sp), | intent(out) | :: | z(ldz,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldz | |||
| complex(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| real(kind=sp), | intent(out) | :: | rwork(*) | |||
| integer(kind=ilp), | intent(in) | :: | lrwork | |||
| integer(kind=ilp), | intent(out) | :: | iwork(*) | |||
| integer(kind=ilp), | intent(in) | :: | liwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | itype | |||
| character, | intent(in) | :: | jobz | |||
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=dp), | intent(inout) | :: | ap(*) | |||
| complex(kind=dp), | intent(inout) | :: | bp(*) | |||
| real(kind=dp), | intent(out) | :: | w(*) | |||
| complex(kind=dp), | intent(out) | :: | z(ldz,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldz | |||
| complex(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| real(kind=dp), | intent(out) | :: | rwork(*) | |||
| integer(kind=ilp), | intent(in) | :: | lrwork | |||
| integer(kind=ilp), | intent(out) | :: | iwork(*) | |||
| integer(kind=ilp), | intent(in) | :: | liwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
CHPGVD computes all the eigenvalues and, optionally, the eigenvectors of a complex generalized Hermitian-definite eigenproblem, of the form Ax=(lambda)Bx, ABx=(lambda)x, or BAx=(lambda)x. Here A and B are assumed to be Hermitian, stored in packed format, and B is also positive definite. If eigenvectors are desired, it uses a divide and conquer algorithm. The divide and conquer algorithm makes very mild assumptions about floating point arithmetic. It will work on machines with a guard digit in add/subtract, or on those binary machines without guard digits which subtract like the Cray X-MP, Cray Y-MP, Cray C-90, or Cray-2. It could conceivably fail on hexadecimal or decimal machines without guard digits, but we know of none.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | itype | |||
| character, | intent(in) | :: | jobz | |||
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=sp), | intent(inout) | :: | ap(*) | |||
| complex(kind=sp), | intent(inout) | :: | bp(*) | |||
| real(kind=sp), | intent(out) | :: | w(*) | |||
| complex(kind=sp), | intent(out) | :: | z(ldz,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldz | |||
| complex(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| real(kind=sp), | intent(out) | :: | rwork(*) | |||
| integer(kind=ilp), | intent(in) | :: | lrwork | |||
| integer(kind=ilp), | intent(out) | :: | iwork(*) | |||
| integer(kind=ilp), | intent(in) | :: | liwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
ZHPGVD computes all the eigenvalues and, optionally, the eigenvectors of a complex generalized Hermitian-definite eigenproblem, of the form Ax=(lambda)Bx, ABx=(lambda)x, or BAx=(lambda)x. Here A and B are assumed to be Hermitian, stored in packed format, and B is also positive definite. If eigenvectors are desired, it uses a divide and conquer algorithm. The divide and conquer algorithm makes very mild assumptions about floating point arithmetic. It will work on machines with a guard digit in add/subtract, or on those binary machines without guard digits which subtract like the Cray X-MP, Cray Y-MP, Cray C-90, or Cray-2. It could conceivably fail on hexadecimal or decimal machines without guard digits, but we know of none.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | itype | |||
| character, | intent(in) | :: | jobz | |||
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=dp), | intent(inout) | :: | ap(*) | |||
| complex(kind=dp), | intent(inout) | :: | bp(*) | |||
| real(kind=dp), | intent(out) | :: | w(*) | |||
| complex(kind=dp), | intent(out) | :: | z(ldz,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldz | |||
| complex(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| real(kind=dp), | intent(out) | :: | rwork(*) | |||
| integer(kind=ilp), | intent(in) | :: | lrwork | |||
| integer(kind=ilp), | intent(out) | :: | iwork(*) | |||
| integer(kind=ilp), | intent(in) | :: | liwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
HPRFS improves the computed solution to a system of linear equations when the coefficient matrix is Hermitian indefinite and packed, and provides error bounds and backward error estimates for the solution.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| complex(kind=sp), | intent(in) | :: | ap(*) | |||
| complex(kind=sp), | intent(in) | :: | afp(*) | |||
| integer(kind=ilp), | intent(in) | :: | ipiv(*) | |||
| complex(kind=sp), | intent(in) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| complex(kind=sp), | intent(inout) | :: | x(ldx,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldx | |||
| real(kind=sp), | intent(out) | :: | ferr(*) | |||
| real(kind=sp), | intent(out) | :: | berr(*) | |||
| complex(kind=sp), | intent(out) | :: | work(*) | |||
| real(kind=sp), | intent(out) | :: | rwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| complex(kind=dp), | intent(in) | :: | ap(*) | |||
| complex(kind=dp), | intent(in) | :: | afp(*) | |||
| integer(kind=ilp), | intent(in) | :: | ipiv(*) | |||
| complex(kind=dp), | intent(in) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| complex(kind=dp), | intent(inout) | :: | x(ldx,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldx | |||
| real(kind=dp), | intent(out) | :: | ferr(*) | |||
| real(kind=dp), | intent(out) | :: | berr(*) | |||
| complex(kind=dp), | intent(out) | :: | work(*) | |||
| real(kind=dp), | intent(out) | :: | rwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
CHPRFS improves the computed solution to a system of linear equations when the coefficient matrix is Hermitian indefinite and packed, and provides error bounds and backward error estimates for the solution.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| complex(kind=sp), | intent(in) | :: | ap(*) | |||
| complex(kind=sp), | intent(in) | :: | afp(*) | |||
| integer(kind=ilp), | intent(in) | :: | ipiv(*) | |||
| complex(kind=sp), | intent(in) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| complex(kind=sp), | intent(inout) | :: | x(ldx,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldx | |||
| real(kind=sp), | intent(out) | :: | ferr(*) | |||
| real(kind=sp), | intent(out) | :: | berr(*) | |||
| complex(kind=sp), | intent(out) | :: | work(*) | |||
| real(kind=sp), | intent(out) | :: | rwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
ZHPRFS improves the computed solution to a system of linear equations when the coefficient matrix is Hermitian indefinite and packed, and provides error bounds and backward error estimates for the solution.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| complex(kind=dp), | intent(in) | :: | ap(*) | |||
| complex(kind=dp), | intent(in) | :: | afp(*) | |||
| integer(kind=ilp), | intent(in) | :: | ipiv(*) | |||
| complex(kind=dp), | intent(in) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| complex(kind=dp), | intent(inout) | :: | x(ldx,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldx | |||
| real(kind=dp), | intent(out) | :: | ferr(*) | |||
| real(kind=dp), | intent(out) | :: | berr(*) | |||
| complex(kind=dp), | intent(out) | :: | work(*) | |||
| real(kind=dp), | intent(out) | :: | rwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
HPSV computes the solution to a complex system of linear equations A * X = B, where A is an N-by-N Hermitian matrix stored in packed format and X and B are N-by-NRHS matrices. The diagonal pivoting method is used to factor A as A = U * D * UH, if UPLO = 'U', or A = L * D * LH, if UPLO = 'L', where U (or L) is a product of permutation and unit upper (lower) triangular matrices, D is Hermitian and block diagonal with 1-by-1 and 2-by-2 diagonal blocks. The factored form of A is then used to solve the system of equations A * X = B.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| complex(kind=sp), | intent(inout) | :: | ap(*) | |||
| integer(kind=ilp), | intent(out) | :: | ipiv(*) | |||
| complex(kind=sp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| complex(kind=dp), | intent(inout) | :: | ap(*) | |||
| integer(kind=ilp), | intent(out) | :: | ipiv(*) | |||
| complex(kind=dp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| integer(kind=ilp), | intent(out) | :: | info |
CHPSV computes the solution to a complex system of linear equations A * X = B, where A is an N-by-N Hermitian matrix stored in packed format and X and B are N-by-NRHS matrices. The diagonal pivoting method is used to factor A as A = U * D * UH, if UPLO = 'U', or A = L * D * LH, if UPLO = 'L', where U (or L) is a product of permutation and unit upper (lower) triangular matrices, D is Hermitian and block diagonal with 1-by-1 and 2-by-2 diagonal blocks. The factored form of A is then used to solve the system of equations A * X = B.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| complex(kind=sp), | intent(inout) | :: | ap(*) | |||
| integer(kind=ilp), | intent(out) | :: | ipiv(*) | |||
| complex(kind=sp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| integer(kind=ilp), | intent(out) | :: | info |
ZHPSV computes the solution to a complex system of linear equations A * X = B, where A is an N-by-N Hermitian matrix stored in packed format and X and B are N-by-NRHS matrices. The diagonal pivoting method is used to factor A as A = U * D * UH, if UPLO = 'U', or A = L * D * LH, if UPLO = 'L', where U (or L) is a product of permutation and unit upper (lower) triangular matrices, D is Hermitian and block diagonal with 1-by-1 and 2-by-2 diagonal blocks. The factored form of A is then used to solve the system of equations A * X = B.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| complex(kind=dp), | intent(inout) | :: | ap(*) | |||
| integer(kind=ilp), | intent(out) | :: | ipiv(*) | |||
| complex(kind=dp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| integer(kind=ilp), | intent(out) | :: | info |
HPTRD reduces a complex Hermitian matrix A stored in packed form to real symmetric tridiagonal form T by a unitary similarity transformation: Q**H * A * Q = T.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=sp), | intent(inout) | :: | ap(*) | |||
| real(kind=sp), | intent(out) | :: | d(*) | |||
| real(kind=sp), | intent(out) | :: | e(*) | |||
| complex(kind=sp), | intent(out) | :: | tau(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=dp), | intent(inout) | :: | ap(*) | |||
| real(kind=dp), | intent(out) | :: | d(*) | |||
| real(kind=dp), | intent(out) | :: | e(*) | |||
| complex(kind=dp), | intent(out) | :: | tau(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
CHPTRD reduces a complex Hermitian matrix A stored in packed form to real symmetric tridiagonal form T by a unitary similarity transformation: Q**H * A * Q = T.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=sp), | intent(inout) | :: | ap(*) | |||
| real(kind=sp), | intent(out) | :: | d(*) | |||
| real(kind=sp), | intent(out) | :: | e(*) | |||
| complex(kind=sp), | intent(out) | :: | tau(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
ZHPTRD reduces a complex Hermitian matrix A stored in packed form to real symmetric tridiagonal form T by a unitary similarity transformation: Q**H * A * Q = T.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=dp), | intent(inout) | :: | ap(*) | |||
| real(kind=dp), | intent(out) | :: | d(*) | |||
| real(kind=dp), | intent(out) | :: | e(*) | |||
| complex(kind=dp), | intent(out) | :: | tau(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
HPTRF computes the factorization of a complex Hermitian packed matrix A using the Bunch-Kaufman diagonal pivoting method: A = UDUH or A = LDLH where U (or L) is a product of permutation and unit upper (lower) triangular matrices, and D is Hermitian and block diagonal with 1-by-1 and 2-by-2 diagonal blocks.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=sp), | intent(inout) | :: | ap(*) | |||
| integer(kind=ilp), | intent(out) | :: | ipiv(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=dp), | intent(inout) | :: | ap(*) | |||
| integer(kind=ilp), | intent(out) | :: | ipiv(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
CHPTRF computes the factorization of a complex Hermitian packed matrix A using the Bunch-Kaufman diagonal pivoting method: A = UDUH or A = LDLH where U (or L) is a product of permutation and unit upper (lower) triangular matrices, and D is Hermitian and block diagonal with 1-by-1 and 2-by-2 diagonal blocks.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=sp), | intent(inout) | :: | ap(*) | |||
| integer(kind=ilp), | intent(out) | :: | ipiv(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
ZHPTRF computes the factorization of a complex Hermitian packed matrix A using the Bunch-Kaufman diagonal pivoting method: A = UDUH or A = LDLH where U (or L) is a product of permutation and unit upper (lower) triangular matrices, and D is Hermitian and block diagonal with 1-by-1 and 2-by-2 diagonal blocks.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=dp), | intent(inout) | :: | ap(*) | |||
| integer(kind=ilp), | intent(out) | :: | ipiv(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
HPTRI computes the inverse of a complex Hermitian indefinite matrix A in packed storage using the factorization A = UDUH or A = LDLH computed by CHPTRF.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=sp), | intent(inout) | :: | ap(*) | |||
| integer(kind=ilp), | intent(in) | :: | ipiv(*) | |||
| complex(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=dp), | intent(inout) | :: | ap(*) | |||
| integer(kind=ilp), | intent(in) | :: | ipiv(*) | |||
| complex(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
CHPTRI computes the inverse of a complex Hermitian indefinite matrix A in packed storage using the factorization A = UDUH or A = LDLH computed by CHPTRF.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=sp), | intent(inout) | :: | ap(*) | |||
| integer(kind=ilp), | intent(in) | :: | ipiv(*) | |||
| complex(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
ZHPTRI computes the inverse of a complex Hermitian indefinite matrix A in packed storage using the factorization A = UDUH or A = LDLH computed by ZHPTRF.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=dp), | intent(inout) | :: | ap(*) | |||
| integer(kind=ilp), | intent(in) | :: | ipiv(*) | |||
| complex(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
HPTRS solves a system of linear equations AX = B with a complex Hermitian matrix A stored in packed format using the factorization A = UDUH or A = LDL*H computed by CHPTRF.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| complex(kind=sp), | intent(in) | :: | ap(*) | |||
| integer(kind=ilp), | intent(in) | :: | ipiv(*) | |||
| complex(kind=sp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| complex(kind=dp), | intent(in) | :: | ap(*) | |||
| integer(kind=ilp), | intent(in) | :: | ipiv(*) | |||
| complex(kind=dp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| integer(kind=ilp), | intent(out) | :: | info |
CHPTRS solves a system of linear equations AX = B with a complex Hermitian matrix A stored in packed format using the factorization A = UDUH or A = LDL*H computed by CHPTRF.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| complex(kind=sp), | intent(in) | :: | ap(*) | |||
| integer(kind=ilp), | intent(in) | :: | ipiv(*) | |||
| complex(kind=sp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| integer(kind=ilp), | intent(out) | :: | info |
ZHPTRS solves a system of linear equations AX = B with a complex Hermitian matrix A stored in packed format using the factorization A = UDUH or A = LDL*H computed by ZHPTRF.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| complex(kind=dp), | intent(in) | :: | ap(*) | |||
| integer(kind=ilp), | intent(in) | :: | ipiv(*) | |||
| complex(kind=dp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| integer(kind=ilp), | intent(out) | :: | info |
HSEIN uses inverse iteration to find specified right and/or left eigenvectors of a complex upper Hessenberg matrix H. The right eigenvector x and the left eigenvector y of the matrix H corresponding to an eigenvalue w are defined by: H * x = w * x, yh * H = w * yh where y**h denotes the conjugate transpose of the vector y.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | side | |||
| character, | intent(in) | :: | eigsrc | |||
| character, | intent(in) | :: | initv | |||
| logical(kind=lk), | intent(in) | :: | select(*) | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=sp), | intent(in) | :: | h(ldh,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldh | |||
| complex(kind=sp), | intent(inout) | :: | w(*) | |||
| complex(kind=sp), | intent(inout) | :: | vl(ldvl,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldvl | |||
| complex(kind=sp), | intent(inout) | :: | vr(ldvr,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldvr | |||
| integer(kind=ilp), | intent(in) | :: | mm | |||
| integer(kind=ilp), | intent(out) | :: | m | |||
| complex(kind=sp), | intent(out) | :: | work(*) | |||
| real(kind=sp), | intent(out) | :: | rwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | ifaill(*) | |||
| integer(kind=ilp), | intent(out) | :: | ifailr(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | side | |||
| character, | intent(in) | :: | eigsrc | |||
| character, | intent(in) | :: | initv | |||
| logical(kind=lk), | intent(inout) | :: | select(*) | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=dp), | intent(in) | :: | h(ldh,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldh | |||
| real(kind=dp), | intent(inout) | :: | wr(*) | |||
| real(kind=dp), | intent(in) | :: | wi(*) | |||
| real(kind=dp), | intent(inout) | :: | vl(ldvl,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldvl | |||
| real(kind=dp), | intent(inout) | :: | vr(ldvr,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldvr | |||
| integer(kind=ilp), | intent(in) | :: | mm | |||
| integer(kind=ilp), | intent(out) | :: | m | |||
| real(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | ifaill(*) | |||
| integer(kind=ilp), | intent(out) | :: | ifailr(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | side | |||
| character, | intent(in) | :: | eigsrc | |||
| character, | intent(in) | :: | initv | |||
| logical(kind=lk), | intent(inout) | :: | select(*) | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=sp), | intent(in) | :: | h(ldh,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldh | |||
| real(kind=sp), | intent(inout) | :: | wr(*) | |||
| real(kind=sp), | intent(in) | :: | wi(*) | |||
| real(kind=sp), | intent(inout) | :: | vl(ldvl,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldvl | |||
| real(kind=sp), | intent(inout) | :: | vr(ldvr,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldvr | |||
| integer(kind=ilp), | intent(in) | :: | mm | |||
| integer(kind=ilp), | intent(out) | :: | m | |||
| real(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | ifaill(*) | |||
| integer(kind=ilp), | intent(out) | :: | ifailr(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | side | |||
| character, | intent(in) | :: | eigsrc | |||
| character, | intent(in) | :: | initv | |||
| logical(kind=lk), | intent(in) | :: | select(*) | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=dp), | intent(in) | :: | h(ldh,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldh | |||
| complex(kind=dp), | intent(inout) | :: | w(*) | |||
| complex(kind=dp), | intent(inout) | :: | vl(ldvl,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldvl | |||
| complex(kind=dp), | intent(inout) | :: | vr(ldvr,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldvr | |||
| integer(kind=ilp), | intent(in) | :: | mm | |||
| integer(kind=ilp), | intent(out) | :: | m | |||
| complex(kind=dp), | intent(out) | :: | work(*) | |||
| real(kind=dp), | intent(out) | :: | rwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | ifaill(*) | |||
| integer(kind=ilp), | intent(out) | :: | ifailr(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
CHSEIN uses inverse iteration to find specified right and/or left eigenvectors of a complex upper Hessenberg matrix H. The right eigenvector x and the left eigenvector y of the matrix H corresponding to an eigenvalue w are defined by: H * x = w * x, yh * H = w * yh where y**h denotes the conjugate transpose of the vector y.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | side | |||
| character, | intent(in) | :: | eigsrc | |||
| character, | intent(in) | :: | initv | |||
| logical(kind=lk), | intent(in) | :: | select(*) | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=sp), | intent(in) | :: | h(ldh,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldh | |||
| complex(kind=sp), | intent(inout) | :: | w(*) | |||
| complex(kind=sp), | intent(inout) | :: | vl(ldvl,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldvl | |||
| complex(kind=sp), | intent(inout) | :: | vr(ldvr,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldvr | |||
| integer(kind=ilp), | intent(in) | :: | mm | |||
| integer(kind=ilp), | intent(out) | :: | m | |||
| complex(kind=sp), | intent(out) | :: | work(*) | |||
| real(kind=sp), | intent(out) | :: | rwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | ifaill(*) | |||
| integer(kind=ilp), | intent(out) | :: | ifailr(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
DHSEIN uses inverse iteration to find specified right and/or left eigenvectors of a real upper Hessenberg matrix H. The right eigenvector x and the left eigenvector y of the matrix H corresponding to an eigenvalue w are defined by: H * x = w * x, yh * H = w * yh where y**h denotes the conjugate transpose of the vector y.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | side | |||
| character, | intent(in) | :: | eigsrc | |||
| character, | intent(in) | :: | initv | |||
| logical(kind=lk), | intent(inout) | :: | select(*) | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=dp), | intent(in) | :: | h(ldh,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldh | |||
| real(kind=dp), | intent(inout) | :: | wr(*) | |||
| real(kind=dp), | intent(in) | :: | wi(*) | |||
| real(kind=dp), | intent(inout) | :: | vl(ldvl,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldvl | |||
| real(kind=dp), | intent(inout) | :: | vr(ldvr,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldvr | |||
| integer(kind=ilp), | intent(in) | :: | mm | |||
| integer(kind=ilp), | intent(out) | :: | m | |||
| real(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | ifaill(*) | |||
| integer(kind=ilp), | intent(out) | :: | ifailr(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
SHSEIN uses inverse iteration to find specified right and/or left eigenvectors of a real upper Hessenberg matrix H. The right eigenvector x and the left eigenvector y of the matrix H corresponding to an eigenvalue w are defined by: H * x = w * x, yh * H = w * yh where y**h denotes the conjugate transpose of the vector y.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | side | |||
| character, | intent(in) | :: | eigsrc | |||
| character, | intent(in) | :: | initv | |||
| logical(kind=lk), | intent(inout) | :: | select(*) | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=sp), | intent(in) | :: | h(ldh,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldh | |||
| real(kind=sp), | intent(inout) | :: | wr(*) | |||
| real(kind=sp), | intent(in) | :: | wi(*) | |||
| real(kind=sp), | intent(inout) | :: | vl(ldvl,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldvl | |||
| real(kind=sp), | intent(inout) | :: | vr(ldvr,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldvr | |||
| integer(kind=ilp), | intent(in) | :: | mm | |||
| integer(kind=ilp), | intent(out) | :: | m | |||
| real(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | ifaill(*) | |||
| integer(kind=ilp), | intent(out) | :: | ifailr(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
ZHSEIN uses inverse iteration to find specified right and/or left eigenvectors of a complex upper Hessenberg matrix H. The right eigenvector x and the left eigenvector y of the matrix H corresponding to an eigenvalue w are defined by: H * x = w * x, yh * H = w * yh where y**h denotes the conjugate transpose of the vector y.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | side | |||
| character, | intent(in) | :: | eigsrc | |||
| character, | intent(in) | :: | initv | |||
| logical(kind=lk), | intent(in) | :: | select(*) | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=dp), | intent(in) | :: | h(ldh,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldh | |||
| complex(kind=dp), | intent(inout) | :: | w(*) | |||
| complex(kind=dp), | intent(inout) | :: | vl(ldvl,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldvl | |||
| complex(kind=dp), | intent(inout) | :: | vr(ldvr,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldvr | |||
| integer(kind=ilp), | intent(in) | :: | mm | |||
| integer(kind=ilp), | intent(out) | :: | m | |||
| complex(kind=dp), | intent(out) | :: | work(*) | |||
| real(kind=dp), | intent(out) | :: | rwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | ifaill(*) | |||
| integer(kind=ilp), | intent(out) | :: | ifailr(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
HSEQR computes the eigenvalues of a Hessenberg matrix H and, optionally, the matrices T and Z from the Schur decomposition H = Z T ZH, where T is an upper triangular matrix (the Schur form), and Z is the unitary matrix of Schur vectors. Optionally Z may be postmultiplied into an input unitary matrix Q so that this routine can give the Schur factorization of a matrix A which has been reduced to the Hessenberg form H by the unitary matrix Q: A = QHQH = (QZ)T(QZ)**H.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | job | |||
| character, | intent(in) | :: | compz | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | ilo | |||
| integer(kind=ilp), | intent(in) | :: | ihi | |||
| complex(kind=sp), | intent(inout) | :: | h(ldh,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldh | |||
| complex(kind=sp), | intent(out) | :: | w(*) | |||
| complex(kind=sp), | intent(inout) | :: | z(ldz,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldz | |||
| complex(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | job | |||
| character, | intent(in) | :: | compz | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | ilo | |||
| integer(kind=ilp), | intent(in) | :: | ihi | |||
| real(kind=dp), | intent(inout) | :: | h(ldh,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldh | |||
| real(kind=dp), | intent(out) | :: | wr(*) | |||
| real(kind=dp), | intent(out) | :: | wi(*) | |||
| real(kind=dp), | intent(inout) | :: | z(ldz,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldz | |||
| real(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | job | |||
| character, | intent(in) | :: | compz | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | ilo | |||
| integer(kind=ilp), | intent(in) | :: | ihi | |||
| real(kind=sp), | intent(inout) | :: | h(ldh,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldh | |||
| real(kind=sp), | intent(out) | :: | wr(*) | |||
| real(kind=sp), | intent(out) | :: | wi(*) | |||
| real(kind=sp), | intent(inout) | :: | z(ldz,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldz | |||
| real(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | job | |||
| character, | intent(in) | :: | compz | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | ilo | |||
| integer(kind=ilp), | intent(in) | :: | ihi | |||
| complex(kind=dp), | intent(inout) | :: | h(ldh,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldh | |||
| complex(kind=dp), | intent(out) | :: | w(*) | |||
| complex(kind=dp), | intent(inout) | :: | z(ldz,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldz | |||
| complex(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
CHSEQR computes the eigenvalues of a Hessenberg matrix H and, optionally, the matrices T and Z from the Schur decomposition H = Z T ZH, where T is an upper triangular matrix (the Schur form), and Z is the unitary matrix of Schur vectors. Optionally Z may be postmultiplied into an input unitary matrix Q so that this routine can give the Schur factorization of a matrix A which has been reduced to the Hessenberg form H by the unitary matrix Q: A = QHQH = (QZ)T(QZ)**H.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | job | |||
| character, | intent(in) | :: | compz | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | ilo | |||
| integer(kind=ilp), | intent(in) | :: | ihi | |||
| complex(kind=sp), | intent(inout) | :: | h(ldh,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldh | |||
| complex(kind=sp), | intent(out) | :: | w(*) | |||
| complex(kind=sp), | intent(inout) | :: | z(ldz,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldz | |||
| complex(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
DHSEQR computes the eigenvalues of a Hessenberg matrix H and, optionally, the matrices T and Z from the Schur decomposition H = Z T ZT, where T is an upper quasi-triangular matrix (the Schur form), and Z is the orthogonal matrix of Schur vectors. Optionally Z may be postmultiplied into an input orthogonal matrix Q so that this routine can give the Schur factorization of a matrix A which has been reduced to the Hessenberg form H by the orthogonal matrix Q: A = QHQT = (QZ)T(QZ)**T.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | job | |||
| character, | intent(in) | :: | compz | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | ilo | |||
| integer(kind=ilp), | intent(in) | :: | ihi | |||
| real(kind=dp), | intent(inout) | :: | h(ldh,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldh | |||
| real(kind=dp), | intent(out) | :: | wr(*) | |||
| real(kind=dp), | intent(out) | :: | wi(*) | |||
| real(kind=dp), | intent(inout) | :: | z(ldz,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldz | |||
| real(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
SHSEQR computes the eigenvalues of a Hessenberg matrix H and, optionally, the matrices T and Z from the Schur decomposition H = Z T ZT, where T is an upper quasi-triangular matrix (the Schur form), and Z is the orthogonal matrix of Schur vectors. Optionally Z may be postmultiplied into an input orthogonal matrix Q so that this routine can give the Schur factorization of a matrix A which has been reduced to the Hessenberg form H by the orthogonal matrix Q: A = QHQT = (QZ)T(QZ)**T.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | job | |||
| character, | intent(in) | :: | compz | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | ilo | |||
| integer(kind=ilp), | intent(in) | :: | ihi | |||
| real(kind=sp), | intent(inout) | :: | h(ldh,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldh | |||
| real(kind=sp), | intent(out) | :: | wr(*) | |||
| real(kind=sp), | intent(out) | :: | wi(*) | |||
| real(kind=sp), | intent(inout) | :: | z(ldz,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldz | |||
| real(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
ZHSEQR computes the eigenvalues of a Hessenberg matrix H and, optionally, the matrices T and Z from the Schur decomposition H = Z T ZH, where T is an upper triangular matrix (the Schur form), and Z is the unitary matrix of Schur vectors. Optionally Z may be postmultiplied into an input unitary matrix Q so that this routine can give the Schur factorization of a matrix A which has been reduced to the Hessenberg form H by the unitary matrix Q: A = QHQH = (QZ)T(QZ)**H.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | job | |||
| character, | intent(in) | :: | compz | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | ilo | |||
| integer(kind=ilp), | intent(in) | :: | ihi | |||
| complex(kind=dp), | intent(inout) | :: | h(ldh,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldh | |||
| complex(kind=dp), | intent(out) | :: | w(*) | |||
| complex(kind=dp), | intent(inout) | :: | z(ldz,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldz | |||
| complex(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
ISNAN returns .TRUE. if its argument is NaN, and .FALSE. otherwise. To be replaced by the Fortran 2003 intrinsic in the future.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| real(kind=dp), | intent(in) | :: | din |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| real(kind=sp), | intent(in) | :: | sin |
DISNAN returns .TRUE. if its argument is NaN, and .FALSE. otherwise. To be replaced by the Fortran 2003 intrinsic in the future.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| real(kind=dp), | intent(in) | :: | din |
SISNAN returns .TRUE. if its argument is NaN, and .FALSE. otherwise. To be replaced by the Fortran 2003 intrinsic in the future.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| real(kind=sp), | intent(in) | :: | sin |
LA_GBAMV performs one of the matrix-vector operations y := alphaabs(A)abs(x) + betaabs(y), or y := alphaabs(A)Tabs(x) + betaabs(y), where alpha and beta are scalars, x and y are vectors and A is an m by n matrix. This function is primarily used in calculating error bounds. To protect against underflow during evaluation, components in the resulting vector are perturbed away from zero by (N+1) times the underflow threshold. To prevent unnecessarily large errors for block-structure embedded in general matrices, "symbolically" zero components are not perturbed. A zero entry is considered "symbolic" if all multiplications involved in computing that entry have at least one zero multiplicand.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | trans | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | kl | |||
| integer(kind=ilp), | intent(in) | :: | ku | |||
| real(kind=sp), | intent(in) | :: | alpha | |||
| complex(kind=sp), | intent(in) | :: | ab(ldab,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldab | |||
| complex(kind=sp), | intent(in) | :: | x(*) | |||
| integer(kind=ilp), | intent(in) | :: | incx | |||
| real(kind=sp), | intent(in) | :: | beta | |||
| real(kind=sp), | intent(inout) | :: | y(*) | |||
| integer(kind=ilp), | intent(in) | :: | incy |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | trans | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | kl | |||
| integer(kind=ilp), | intent(in) | :: | ku | |||
| real(kind=dp), | intent(in) | :: | alpha | |||
| real(kind=dp), | intent(in) | :: | ab(ldab,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldab | |||
| real(kind=dp), | intent(in) | :: | x(*) | |||
| integer(kind=ilp), | intent(in) | :: | incx | |||
| real(kind=dp), | intent(in) | :: | beta | |||
| real(kind=dp), | intent(inout) | :: | y(*) | |||
| integer(kind=ilp), | intent(in) | :: | incy |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | trans | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | kl | |||
| integer(kind=ilp), | intent(in) | :: | ku | |||
| real(kind=sp), | intent(in) | :: | alpha | |||
| real(kind=sp), | intent(in) | :: | ab(ldab,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldab | |||
| real(kind=sp), | intent(in) | :: | x(*) | |||
| integer(kind=ilp), | intent(in) | :: | incx | |||
| real(kind=sp), | intent(in) | :: | beta | |||
| real(kind=sp), | intent(inout) | :: | y(*) | |||
| integer(kind=ilp), | intent(in) | :: | incy |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | trans | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | kl | |||
| integer(kind=ilp), | intent(in) | :: | ku | |||
| real(kind=dp), | intent(in) | :: | alpha | |||
| complex(kind=dp), | intent(in) | :: | ab(ldab,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldab | |||
| complex(kind=dp), | intent(in) | :: | x(*) | |||
| integer(kind=ilp), | intent(in) | :: | incx | |||
| real(kind=dp), | intent(in) | :: | beta | |||
| real(kind=dp), | intent(inout) | :: | y(*) | |||
| integer(kind=ilp), | intent(in) | :: | incy |
CLA_GBAMV performs one of the matrix-vector operations y := alphaabs(A)abs(x) + betaabs(y), or y := alphaabs(A)Tabs(x) + betaabs(y), where alpha and beta are scalars, x and y are vectors and A is an m by n matrix. This function is primarily used in calculating error bounds. To protect against underflow during evaluation, components in the resulting vector are perturbed away from zero by (N+1) times the underflow threshold. To prevent unnecessarily large errors for block-structure embedded in general matrices, "symbolically" zero components are not perturbed. A zero entry is considered "symbolic" if all multiplications involved in computing that entry have at least one zero multiplicand.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | trans | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | kl | |||
| integer(kind=ilp), | intent(in) | :: | ku | |||
| real(kind=sp), | intent(in) | :: | alpha | |||
| complex(kind=sp), | intent(in) | :: | ab(ldab,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldab | |||
| complex(kind=sp), | intent(in) | :: | x(*) | |||
| integer(kind=ilp), | intent(in) | :: | incx | |||
| real(kind=sp), | intent(in) | :: | beta | |||
| real(kind=sp), | intent(inout) | :: | y(*) | |||
| integer(kind=ilp), | intent(in) | :: | incy |
DLA_GBAMV performs one of the matrix-vector operations y := alphaabs(A)abs(x) + betaabs(y), or y := alphaabs(A)Tabs(x) + betaabs(y), where alpha and beta are scalars, x and y are vectors and A is an m by n matrix. This function is primarily used in calculating error bounds. To protect against underflow during evaluation, components in the resulting vector are perturbed away from zero by (N+1) times the underflow threshold. To prevent unnecessarily large errors for block-structure embedded in general matrices, "symbolically" zero components are not perturbed. A zero entry is considered "symbolic" if all multiplications involved in computing that entry have at least one zero multiplicand.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | trans | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | kl | |||
| integer(kind=ilp), | intent(in) | :: | ku | |||
| real(kind=dp), | intent(in) | :: | alpha | |||
| real(kind=dp), | intent(in) | :: | ab(ldab,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldab | |||
| real(kind=dp), | intent(in) | :: | x(*) | |||
| integer(kind=ilp), | intent(in) | :: | incx | |||
| real(kind=dp), | intent(in) | :: | beta | |||
| real(kind=dp), | intent(inout) | :: | y(*) | |||
| integer(kind=ilp), | intent(in) | :: | incy |
SLA_GBAMV performs one of the matrix-vector operations y := alphaabs(A)abs(x) + betaabs(y), or y := alphaabs(A)Tabs(x) + betaabs(y), where alpha and beta are scalars, x and y are vectors and A is an m by n matrix. This function is primarily used in calculating error bounds. To protect against underflow during evaluation, components in the resulting vector are perturbed away from zero by (N+1) times the underflow threshold. To prevent unnecessarily large errors for block-structure embedded in general matrices, "symbolically" zero components are not perturbed. A zero entry is considered "symbolic" if all multiplications involved in computing that entry have at least one zero multiplicand.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | trans | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | kl | |||
| integer(kind=ilp), | intent(in) | :: | ku | |||
| real(kind=sp), | intent(in) | :: | alpha | |||
| real(kind=sp), | intent(in) | :: | ab(ldab,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldab | |||
| real(kind=sp), | intent(in) | :: | x(*) | |||
| integer(kind=ilp), | intent(in) | :: | incx | |||
| real(kind=sp), | intent(in) | :: | beta | |||
| real(kind=sp), | intent(inout) | :: | y(*) | |||
| integer(kind=ilp), | intent(in) | :: | incy |
ZLA_GBAMV performs one of the matrix-vector operations y := alphaabs(A)abs(x) + betaabs(y), or y := alphaabs(A)Tabs(x) + betaabs(y), where alpha and beta are scalars, x and y are vectors and A is an m by n matrix. This function is primarily used in calculating error bounds. To protect against underflow during evaluation, components in the resulting vector are perturbed away from zero by (N+1) times the underflow threshold. To prevent unnecessarily large errors for block-structure embedded in general matrices, "symbolically" zero components are not perturbed. A zero entry is considered "symbolic" if all multiplications involved in computing that entry have at least one zero multiplicand.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | trans | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | kl | |||
| integer(kind=ilp), | intent(in) | :: | ku | |||
| real(kind=dp), | intent(in) | :: | alpha | |||
| complex(kind=dp), | intent(in) | :: | ab(ldab,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldab | |||
| complex(kind=dp), | intent(in) | :: | x(*) | |||
| integer(kind=ilp), | intent(in) | :: | incx | |||
| real(kind=dp), | intent(in) | :: | beta | |||
| real(kind=dp), | intent(inout) | :: | y(*) | |||
| integer(kind=ilp), | intent(in) | :: | incy |
LA_GBRCOND Estimates the Skeel condition number of op(A) * op2(C) where op2 is determined by CMODE as follows CMODE = 1 op2(C) = C CMODE = 0 op2(C) = I CMODE = -1 op2(C) = inv(C) The Skeel condition number cond(A) = norminf( |inv(A)||A| ) is computed by computing scaling factors R such that diag(R)Aop2(C) is row equilibrated and computing the standard infinity-norm condition number.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | trans | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | kl | |||
| integer(kind=ilp), | intent(in) | :: | ku | |||
| real(kind=dp), | intent(in) | :: | ab(ldab,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldab | |||
| real(kind=dp), | intent(in) | :: | afb(ldafb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldafb | |||
| integer(kind=ilp), | intent(in) | :: | ipiv(*) | |||
| integer(kind=ilp), | intent(in) | :: | cmode | |||
| real(kind=dp), | intent(in) | :: | c(*) | |||
| integer(kind=ilp), | intent(out) | :: | info | |||
| real(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | iwork(*) |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | trans | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | kl | |||
| integer(kind=ilp), | intent(in) | :: | ku | |||
| real(kind=sp), | intent(in) | :: | ab(ldab,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldab | |||
| real(kind=sp), | intent(in) | :: | afb(ldafb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldafb | |||
| integer(kind=ilp), | intent(in) | :: | ipiv(*) | |||
| integer(kind=ilp), | intent(in) | :: | cmode | |||
| real(kind=sp), | intent(in) | :: | c(*) | |||
| integer(kind=ilp), | intent(out) | :: | info | |||
| real(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | iwork(*) |
DLA_GBRCOND Estimates the Skeel condition number of op(A) * op2(C) where op2 is determined by CMODE as follows CMODE = 1 op2(C) = C CMODE = 0 op2(C) = I CMODE = -1 op2(C) = inv(C) The Skeel condition number cond(A) = norminf( |inv(A)||A| ) is computed by computing scaling factors R such that diag(R)Aop2(C) is row equilibrated and computing the standard infinity-norm condition number.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | trans | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | kl | |||
| integer(kind=ilp), | intent(in) | :: | ku | |||
| real(kind=dp), | intent(in) | :: | ab(ldab,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldab | |||
| real(kind=dp), | intent(in) | :: | afb(ldafb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldafb | |||
| integer(kind=ilp), | intent(in) | :: | ipiv(*) | |||
| integer(kind=ilp), | intent(in) | :: | cmode | |||
| real(kind=dp), | intent(in) | :: | c(*) | |||
| integer(kind=ilp), | intent(out) | :: | info | |||
| real(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | iwork(*) |
SLA_GBRCOND Estimates the Skeel condition number of op(A) * op2(C) where op2 is determined by CMODE as follows CMODE = 1 op2(C) = C CMODE = 0 op2(C) = I CMODE = -1 op2(C) = inv(C) The Skeel condition number cond(A) = norminf( |inv(A)||A| ) is computed by computing scaling factors R such that diag(R)Aop2(C) is row equilibrated and computing the standard infinity-norm condition number.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | trans | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | kl | |||
| integer(kind=ilp), | intent(in) | :: | ku | |||
| real(kind=sp), | intent(in) | :: | ab(ldab,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldab | |||
| real(kind=sp), | intent(in) | :: | afb(ldafb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldafb | |||
| integer(kind=ilp), | intent(in) | :: | ipiv(*) | |||
| integer(kind=ilp), | intent(in) | :: | cmode | |||
| real(kind=sp), | intent(in) | :: | c(*) | |||
| integer(kind=ilp), | intent(out) | :: | info | |||
| real(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | iwork(*) |
LA_GBRCOND_C Computes the infinity norm condition number of op(A) * inv(diag(C)) where C is a REAL vector.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | trans | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | kl | |||
| integer(kind=ilp), | intent(in) | :: | ku | |||
| complex(kind=sp), | intent(in) | :: | ab(ldab,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldab | |||
| complex(kind=sp), | intent(in) | :: | afb(ldafb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldafb | |||
| integer(kind=ilp), | intent(in) | :: | ipiv(*) | |||
| real(kind=sp), | intent(in) | :: | c(*) | |||
| logical(kind=lk), | intent(in) | :: | capply | |||
| integer(kind=ilp), | intent(out) | :: | info | |||
| complex(kind=sp), | intent(out) | :: | work(*) | |||
| real(kind=sp), | intent(out) | :: | rwork(*) |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | trans | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | kl | |||
| integer(kind=ilp), | intent(in) | :: | ku | |||
| complex(kind=dp), | intent(in) | :: | ab(ldab,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldab | |||
| complex(kind=dp), | intent(in) | :: | afb(ldafb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldafb | |||
| integer(kind=ilp), | intent(in) | :: | ipiv(*) | |||
| real(kind=dp), | intent(in) | :: | c(*) | |||
| logical(kind=lk), | intent(in) | :: | capply | |||
| integer(kind=ilp), | intent(out) | :: | info | |||
| complex(kind=dp), | intent(out) | :: | work(*) | |||
| real(kind=dp), | intent(out) | :: | rwork(*) |
CLA_GBRCOND_C Computes the infinity norm condition number of op(A) * inv(diag(C)) where C is a REAL vector.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | trans | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | kl | |||
| integer(kind=ilp), | intent(in) | :: | ku | |||
| complex(kind=sp), | intent(in) | :: | ab(ldab,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldab | |||
| complex(kind=sp), | intent(in) | :: | afb(ldafb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldafb | |||
| integer(kind=ilp), | intent(in) | :: | ipiv(*) | |||
| real(kind=sp), | intent(in) | :: | c(*) | |||
| logical(kind=lk), | intent(in) | :: | capply | |||
| integer(kind=ilp), | intent(out) | :: | info | |||
| complex(kind=sp), | intent(out) | :: | work(*) | |||
| real(kind=sp), | intent(out) | :: | rwork(*) |
ZLA_GBRCOND_C Computes the infinity norm condition number of op(A) * inv(diag(C)) where C is a DOUBLE PRECISION vector.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | trans | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | kl | |||
| integer(kind=ilp), | intent(in) | :: | ku | |||
| complex(kind=dp), | intent(in) | :: | ab(ldab,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldab | |||
| complex(kind=dp), | intent(in) | :: | afb(ldafb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldafb | |||
| integer(kind=ilp), | intent(in) | :: | ipiv(*) | |||
| real(kind=dp), | intent(in) | :: | c(*) | |||
| logical(kind=lk), | intent(in) | :: | capply | |||
| integer(kind=ilp), | intent(out) | :: | info | |||
| complex(kind=dp), | intent(out) | :: | work(*) | |||
| real(kind=dp), | intent(out) | :: | rwork(*) |
LA_GBRPVGRW computes the reciprocal pivot growth factor norm(A)/norm(U). The "max absolute element" norm is used. If this is much less than 1, the stability of the LU factorization of the (equilibrated) matrix A could be poor. This also means that the solution X, estimated condition numbers, and error bounds could be unreliable.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | kl | |||
| integer(kind=ilp), | intent(in) | :: | ku | |||
| integer(kind=ilp), | intent(in) | :: | ncols | |||
| complex(kind=sp), | intent(in) | :: | ab(ldab,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldab | |||
| complex(kind=sp), | intent(in) | :: | afb(ldafb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldafb |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | kl | |||
| integer(kind=ilp), | intent(in) | :: | ku | |||
| integer(kind=ilp), | intent(in) | :: | ncols | |||
| real(kind=dp), | intent(in) | :: | ab(ldab,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldab | |||
| real(kind=dp), | intent(in) | :: | afb(ldafb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldafb |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | kl | |||
| integer(kind=ilp), | intent(in) | :: | ku | |||
| integer(kind=ilp), | intent(in) | :: | ncols | |||
| real(kind=sp), | intent(in) | :: | ab(ldab,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldab | |||
| real(kind=sp), | intent(in) | :: | afb(ldafb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldafb |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | kl | |||
| integer(kind=ilp), | intent(in) | :: | ku | |||
| integer(kind=ilp), | intent(in) | :: | ncols | |||
| complex(kind=dp), | intent(in) | :: | ab(ldab,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldab | |||
| complex(kind=dp), | intent(in) | :: | afb(ldafb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldafb |
CLA_GBRPVGRW computes the reciprocal pivot growth factor norm(A)/norm(U). The "max absolute element" norm is used. If this is much less than 1, the stability of the LU factorization of the (equilibrated) matrix A could be poor. This also means that the solution X, estimated condition numbers, and error bounds could be unreliable.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | kl | |||
| integer(kind=ilp), | intent(in) | :: | ku | |||
| integer(kind=ilp), | intent(in) | :: | ncols | |||
| complex(kind=sp), | intent(in) | :: | ab(ldab,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldab | |||
| complex(kind=sp), | intent(in) | :: | afb(ldafb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldafb |
DLA_GBRPVGRW computes the reciprocal pivot growth factor norm(A)/norm(U). The "max absolute element" norm is used. If this is much less than 1, the stability of the LU factorization of the (equilibrated) matrix A could be poor. This also means that the solution X, estimated condition numbers, and error bounds could be unreliable.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | kl | |||
| integer(kind=ilp), | intent(in) | :: | ku | |||
| integer(kind=ilp), | intent(in) | :: | ncols | |||
| real(kind=dp), | intent(in) | :: | ab(ldab,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldab | |||
| real(kind=dp), | intent(in) | :: | afb(ldafb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldafb |
SLA_GBRPVGRW computes the reciprocal pivot growth factor norm(A)/norm(U). The "max absolute element" norm is used. If this is much less than 1, the stability of the LU factorization of the (equilibrated) matrix A could be poor. This also means that the solution X, estimated condition numbers, and error bounds could be unreliable.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | kl | |||
| integer(kind=ilp), | intent(in) | :: | ku | |||
| integer(kind=ilp), | intent(in) | :: | ncols | |||
| real(kind=sp), | intent(in) | :: | ab(ldab,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldab | |||
| real(kind=sp), | intent(in) | :: | afb(ldafb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldafb |
ZLA_GBRPVGRW computes the reciprocal pivot growth factor norm(A)/norm(U). The "max absolute element" norm is used. If this is much less than 1, the stability of the LU factorization of the (equilibrated) matrix A could be poor. This also means that the solution X, estimated condition numbers, and error bounds could be unreliable.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | kl | |||
| integer(kind=ilp), | intent(in) | :: | ku | |||
| integer(kind=ilp), | intent(in) | :: | ncols | |||
| complex(kind=dp), | intent(in) | :: | ab(ldab,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldab | |||
| complex(kind=dp), | intent(in) | :: | afb(ldafb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldafb |
LA_GEAMV performs one of the matrix-vector operations y := alphaabs(A)abs(x) + betaabs(y), or y := alphaabs(A)Tabs(x) + betaabs(y), where alpha and beta are scalars, x and y are vectors and A is an m by n matrix. This function is primarily used in calculating error bounds. To protect against underflow during evaluation, components in the resulting vector are perturbed away from zero by (N+1) times the underflow threshold. To prevent unnecessarily large errors for block-structure embedded in general matrices, "symbolically" zero components are not perturbed. A zero entry is considered "symbolic" if all multiplications involved in computing that entry have at least one zero multiplicand.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | trans | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=sp), | intent(in) | :: | alpha | |||
| complex(kind=sp), | intent(in) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=sp), | intent(in) | :: | x(*) | |||
| integer(kind=ilp), | intent(in) | :: | incx | |||
| real(kind=sp), | intent(in) | :: | beta | |||
| real(kind=sp), | intent(inout) | :: | y(*) | |||
| integer(kind=ilp), | intent(in) | :: | incy |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | trans | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=dp), | intent(in) | :: | alpha | |||
| real(kind=dp), | intent(in) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=dp), | intent(in) | :: | x(*) | |||
| integer(kind=ilp), | intent(in) | :: | incx | |||
| real(kind=dp), | intent(in) | :: | beta | |||
| real(kind=dp), | intent(inout) | :: | y(*) | |||
| integer(kind=ilp), | intent(in) | :: | incy |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | trans | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=sp), | intent(in) | :: | alpha | |||
| real(kind=sp), | intent(in) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=sp), | intent(in) | :: | x(*) | |||
| integer(kind=ilp), | intent(in) | :: | incx | |||
| real(kind=sp), | intent(in) | :: | beta | |||
| real(kind=sp), | intent(inout) | :: | y(*) | |||
| integer(kind=ilp), | intent(in) | :: | incy |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | trans | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=dp), | intent(in) | :: | alpha | |||
| complex(kind=dp), | intent(in) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=dp), | intent(in) | :: | x(*) | |||
| integer(kind=ilp), | intent(in) | :: | incx | |||
| real(kind=dp), | intent(in) | :: | beta | |||
| real(kind=dp), | intent(inout) | :: | y(*) | |||
| integer(kind=ilp), | intent(in) | :: | incy |
CLA_GEAMV performs one of the matrix-vector operations y := alphaabs(A)abs(x) + betaabs(y), or y := alphaabs(A)Tabs(x) + betaabs(y), where alpha and beta are scalars, x and y are vectors and A is an m by n matrix. This function is primarily used in calculating error bounds. To protect against underflow during evaluation, components in the resulting vector are perturbed away from zero by (N+1) times the underflow threshold. To prevent unnecessarily large errors for block-structure embedded in general matrices, "symbolically" zero components are not perturbed. A zero entry is considered "symbolic" if all multiplications involved in computing that entry have at least one zero multiplicand.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | trans | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=sp), | intent(in) | :: | alpha | |||
| complex(kind=sp), | intent(in) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=sp), | intent(in) | :: | x(*) | |||
| integer(kind=ilp), | intent(in) | :: | incx | |||
| real(kind=sp), | intent(in) | :: | beta | |||
| real(kind=sp), | intent(inout) | :: | y(*) | |||
| integer(kind=ilp), | intent(in) | :: | incy |
DLA_GEAMV performs one of the matrix-vector operations y := alphaabs(A)abs(x) + betaabs(y), or y := alphaabs(A)Tabs(x) + betaabs(y), where alpha and beta are scalars, x and y are vectors and A is an m by n matrix. This function is primarily used in calculating error bounds. To protect against underflow during evaluation, components in the resulting vector are perturbed away from zero by (N+1) times the underflow threshold. To prevent unnecessarily large errors for block-structure embedded in general matrices, "symbolically" zero components are not perturbed. A zero entry is considered "symbolic" if all multiplications involved in computing that entry have at least one zero multiplicand.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | trans | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=dp), | intent(in) | :: | alpha | |||
| real(kind=dp), | intent(in) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=dp), | intent(in) | :: | x(*) | |||
| integer(kind=ilp), | intent(in) | :: | incx | |||
| real(kind=dp), | intent(in) | :: | beta | |||
| real(kind=dp), | intent(inout) | :: | y(*) | |||
| integer(kind=ilp), | intent(in) | :: | incy |
SLA_GEAMV performs one of the matrix-vector operations y := alphaabs(A)abs(x) + betaabs(y), or y := alphaabs(A)Tabs(x) + betaabs(y), where alpha and beta are scalars, x and y are vectors and A is an m by n matrix. This function is primarily used in calculating error bounds. To protect against underflow during evaluation, components in the resulting vector are perturbed away from zero by (N+1) times the underflow threshold. To prevent unnecessarily large errors for block-structure embedded in general matrices, "symbolically" zero components are not perturbed. A zero entry is considered "symbolic" if all multiplications involved in computing that entry have at least one zero multiplicand.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | trans | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=sp), | intent(in) | :: | alpha | |||
| real(kind=sp), | intent(in) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=sp), | intent(in) | :: | x(*) | |||
| integer(kind=ilp), | intent(in) | :: | incx | |||
| real(kind=sp), | intent(in) | :: | beta | |||
| real(kind=sp), | intent(inout) | :: | y(*) | |||
| integer(kind=ilp), | intent(in) | :: | incy |
ZLA_GEAMV performs one of the matrix-vector operations y := alphaabs(A)abs(x) + betaabs(y), or y := alphaabs(A)Tabs(x) + betaabs(y), where alpha and beta are scalars, x and y are vectors and A is an m by n matrix. This function is primarily used in calculating error bounds. To protect against underflow during evaluation, components in the resulting vector are perturbed away from zero by (N+1) times the underflow threshold. To prevent unnecessarily large errors for block-structure embedded in general matrices, "symbolically" zero components are not perturbed. A zero entry is considered "symbolic" if all multiplications involved in computing that entry have at least one zero multiplicand.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | trans | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=dp), | intent(in) | :: | alpha | |||
| complex(kind=dp), | intent(in) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=dp), | intent(in) | :: | x(*) | |||
| integer(kind=ilp), | intent(in) | :: | incx | |||
| real(kind=dp), | intent(in) | :: | beta | |||
| real(kind=dp), | intent(inout) | :: | y(*) | |||
| integer(kind=ilp), | intent(in) | :: | incy |
LA_GERCOND estimates the Skeel condition number of op(A) * op2(C) where op2 is determined by CMODE as follows CMODE = 1 op2(C) = C CMODE = 0 op2(C) = I CMODE = -1 op2(C) = inv(C) The Skeel condition number cond(A) = norminf( |inv(A)||A| ) is computed by computing scaling factors R such that diag(R)Aop2(C) is row equilibrated and computing the standard infinity-norm condition number.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | trans | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=dp), | intent(in) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=dp), | intent(in) | :: | af(ldaf,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldaf | |||
| integer(kind=ilp), | intent(in) | :: | ipiv(*) | |||
| integer(kind=ilp), | intent(in) | :: | cmode | |||
| real(kind=dp), | intent(in) | :: | c(*) | |||
| integer(kind=ilp), | intent(out) | :: | info | |||
| real(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | iwork(*) |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | trans | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=sp), | intent(in) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=sp), | intent(in) | :: | af(ldaf,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldaf | |||
| integer(kind=ilp), | intent(in) | :: | ipiv(*) | |||
| integer(kind=ilp), | intent(in) | :: | cmode | |||
| real(kind=sp), | intent(in) | :: | c(*) | |||
| integer(kind=ilp), | intent(out) | :: | info | |||
| real(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | iwork(*) |
DLA_GERCOND estimates the Skeel condition number of op(A) * op2(C) where op2 is determined by CMODE as follows CMODE = 1 op2(C) = C CMODE = 0 op2(C) = I CMODE = -1 op2(C) = inv(C) The Skeel condition number cond(A) = norminf( |inv(A)||A| ) is computed by computing scaling factors R such that diag(R)Aop2(C) is row equilibrated and computing the standard infinity-norm condition number.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | trans | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=dp), | intent(in) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=dp), | intent(in) | :: | af(ldaf,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldaf | |||
| integer(kind=ilp), | intent(in) | :: | ipiv(*) | |||
| integer(kind=ilp), | intent(in) | :: | cmode | |||
| real(kind=dp), | intent(in) | :: | c(*) | |||
| integer(kind=ilp), | intent(out) | :: | info | |||
| real(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | iwork(*) |
SLA_GERCOND estimates the Skeel condition number of op(A) * op2(C) where op2 is determined by CMODE as follows CMODE = 1 op2(C) = C CMODE = 0 op2(C) = I CMODE = -1 op2(C) = inv(C) The Skeel condition number cond(A) = norminf( |inv(A)||A| ) is computed by computing scaling factors R such that diag(R)Aop2(C) is row equilibrated and computing the standard infinity-norm condition number.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | trans | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=sp), | intent(in) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=sp), | intent(in) | :: | af(ldaf,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldaf | |||
| integer(kind=ilp), | intent(in) | :: | ipiv(*) | |||
| integer(kind=ilp), | intent(in) | :: | cmode | |||
| real(kind=sp), | intent(in) | :: | c(*) | |||
| integer(kind=ilp), | intent(out) | :: | info | |||
| real(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | iwork(*) |
LA_GERCOND_C computes the infinity norm condition number of op(A) * inv(diag(C)) where C is a REAL vector.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | trans | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=sp), | intent(in) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=sp), | intent(in) | :: | af(ldaf,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldaf | |||
| integer(kind=ilp), | intent(in) | :: | ipiv(*) | |||
| real(kind=sp), | intent(in) | :: | c(*) | |||
| logical(kind=lk), | intent(in) | :: | capply | |||
| integer(kind=ilp), | intent(out) | :: | info | |||
| complex(kind=sp), | intent(out) | :: | work(*) | |||
| real(kind=sp), | intent(out) | :: | rwork(*) |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | trans | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=dp), | intent(in) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=dp), | intent(in) | :: | af(ldaf,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldaf | |||
| integer(kind=ilp), | intent(in) | :: | ipiv(*) | |||
| real(kind=dp), | intent(in) | :: | c(*) | |||
| logical(kind=lk), | intent(in) | :: | capply | |||
| integer(kind=ilp), | intent(out) | :: | info | |||
| complex(kind=dp), | intent(out) | :: | work(*) | |||
| real(kind=dp), | intent(out) | :: | rwork(*) |
CLA_GERCOND_C computes the infinity norm condition number of op(A) * inv(diag(C)) where C is a REAL vector.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | trans | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=sp), | intent(in) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=sp), | intent(in) | :: | af(ldaf,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldaf | |||
| integer(kind=ilp), | intent(in) | :: | ipiv(*) | |||
| real(kind=sp), | intent(in) | :: | c(*) | |||
| logical(kind=lk), | intent(in) | :: | capply | |||
| integer(kind=ilp), | intent(out) | :: | info | |||
| complex(kind=sp), | intent(out) | :: | work(*) | |||
| real(kind=sp), | intent(out) | :: | rwork(*) |
ZLA_GERCOND_C computes the infinity norm condition number of op(A) * inv(diag(C)) where C is a DOUBLE PRECISION vector.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | trans | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=dp), | intent(in) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=dp), | intent(in) | :: | af(ldaf,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldaf | |||
| integer(kind=ilp), | intent(in) | :: | ipiv(*) | |||
| real(kind=dp), | intent(in) | :: | c(*) | |||
| logical(kind=lk), | intent(in) | :: | capply | |||
| integer(kind=ilp), | intent(out) | :: | info | |||
| complex(kind=dp), | intent(out) | :: | work(*) | |||
| real(kind=dp), | intent(out) | :: | rwork(*) |
LA_GERPVGRW computes the reciprocal pivot growth factor norm(A)/norm(U). The "max absolute element" norm is used. If this is much less than 1, the stability of the LU factorization of the (equilibrated) matrix A could be poor. This also means that the solution X, estimated condition numbers, and error bounds could be unreliable.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | ncols | |||
| complex(kind=sp), | intent(in) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=sp), | intent(in) | :: | af(ldaf,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldaf |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | ncols | |||
| real(kind=dp), | intent(in) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=dp), | intent(in) | :: | af(ldaf,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldaf |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | ncols | |||
| real(kind=sp), | intent(in) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=sp), | intent(in) | :: | af(ldaf,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldaf |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | ncols | |||
| complex(kind=dp), | intent(in) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=dp), | intent(in) | :: | af(ldaf,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldaf |
CLA_GERPVGRW computes the reciprocal pivot growth factor norm(A)/norm(U). The "max absolute element" norm is used. If this is much less than 1, the stability of the LU factorization of the (equilibrated) matrix A could be poor. This also means that the solution X, estimated condition numbers, and error bounds could be unreliable.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | ncols | |||
| complex(kind=sp), | intent(in) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=sp), | intent(in) | :: | af(ldaf,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldaf |
DLA_GERPVGRW computes the reciprocal pivot growth factor norm(A)/norm(U). The "max absolute element" norm is used. If this is much less than 1, the stability of the LU factorization of the (equilibrated) matrix A could be poor. This also means that the solution X, estimated condition numbers, and error bounds could be unreliable.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | ncols | |||
| real(kind=dp), | intent(in) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=dp), | intent(in) | :: | af(ldaf,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldaf |
SLA_GERPVGRW computes the reciprocal pivot growth factor norm(A)/norm(U). The "max absolute element" norm is used. If this is much less than 1, the stability of the LU factorization of the (equilibrated) matrix A could be poor. This also means that the solution X, estimated condition numbers, and error bounds could be unreliable.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | ncols | |||
| real(kind=sp), | intent(in) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=sp), | intent(in) | :: | af(ldaf,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldaf |
ZLA_GERPVGRW computes the reciprocal pivot growth factor norm(A)/norm(U). The "max absolute element" norm is used. If this is much less than 1, the stability of the LU factorization of the (equilibrated) matrix A could be poor. This also means that the solution X, estimated condition numbers, and error bounds could be unreliable.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | ncols | |||
| complex(kind=dp), | intent(in) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=dp), | intent(in) | :: | af(ldaf,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldaf |
CLA_SYAMV performs the matrix-vector operation y := alphaabs(A)abs(x) + beta*abs(y), where alpha and beta are scalars, x and y are vectors and A is an n by n symmetric matrix. This function is primarily used in calculating error bounds. To protect against underflow during evaluation, components in the resulting vector are perturbed away from zero by (N+1) times the underflow threshold. To prevent unnecessarily large errors for block-structure embedded in general matrices, "symbolically" zero components are not perturbed. A zero entry is considered "symbolic" if all multiplications involved in computing that entry have at least one zero multiplicand.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=sp), | intent(in) | :: | alpha | |||
| complex(kind=sp), | intent(in) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=sp), | intent(in) | :: | x(*) | |||
| integer(kind=ilp), | intent(in) | :: | incx | |||
| real(kind=sp), | intent(in) | :: | beta | |||
| real(kind=sp), | intent(inout) | :: | y(*) | |||
| integer(kind=ilp), | intent(in) | :: | incy |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=dp), | intent(in) | :: | alpha | |||
| complex(kind=dp), | intent(in) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=dp), | intent(in) | :: | x(*) | |||
| integer(kind=ilp), | intent(in) | :: | incx | |||
| real(kind=dp), | intent(in) | :: | beta | |||
| real(kind=dp), | intent(inout) | :: | y(*) | |||
| integer(kind=ilp), | intent(in) | :: | incy |
CLA_SYAMV performs the matrix-vector operation y := alphaabs(A)abs(x) + beta*abs(y), where alpha and beta are scalars, x and y are vectors and A is an n by n symmetric matrix. This function is primarily used in calculating error bounds. To protect against underflow during evaluation, components in the resulting vector are perturbed away from zero by (N+1) times the underflow threshold. To prevent unnecessarily large errors for block-structure embedded in general matrices, "symbolically" zero components are not perturbed. A zero entry is considered "symbolic" if all multiplications involved in computing that entry have at least one zero multiplicand.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=sp), | intent(in) | :: | alpha | |||
| complex(kind=sp), | intent(in) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=sp), | intent(in) | :: | x(*) | |||
| integer(kind=ilp), | intent(in) | :: | incx | |||
| real(kind=sp), | intent(in) | :: | beta | |||
| real(kind=sp), | intent(inout) | :: | y(*) | |||
| integer(kind=ilp), | intent(in) | :: | incy |
ZLA_SYAMV performs the matrix-vector operation y := alphaabs(A)abs(x) + beta*abs(y), where alpha and beta are scalars, x and y are vectors and A is an n by n symmetric matrix. This function is primarily used in calculating error bounds. To protect against underflow during evaluation, components in the resulting vector are perturbed away from zero by (N+1) times the underflow threshold. To prevent unnecessarily large errors for block-structure embedded in general matrices, "symbolically" zero components are not perturbed. A zero entry is considered "symbolic" if all multiplications involved in computing that entry have at least one zero multiplicand.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=dp), | intent(in) | :: | alpha | |||
| complex(kind=dp), | intent(in) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=dp), | intent(in) | :: | x(*) | |||
| integer(kind=ilp), | intent(in) | :: | incx | |||
| real(kind=dp), | intent(in) | :: | beta | |||
| real(kind=dp), | intent(inout) | :: | y(*) | |||
| integer(kind=ilp), | intent(in) | :: | incy |
LA_HERCOND_C computes the infinity norm condition number of op(A) * inv(diag(C)) where C is a REAL vector.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=sp), | intent(in) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=sp), | intent(in) | :: | af(ldaf,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldaf | |||
| integer(kind=ilp), | intent(in) | :: | ipiv(*) | |||
| real(kind=sp), | intent(in) | :: | c(*) | |||
| logical(kind=lk), | intent(in) | :: | capply | |||
| integer(kind=ilp), | intent(out) | :: | info | |||
| complex(kind=sp), | intent(out) | :: | work(*) | |||
| real(kind=sp), | intent(out) | :: | rwork(*) |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=dp), | intent(in) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=dp), | intent(in) | :: | af(ldaf,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldaf | |||
| integer(kind=ilp), | intent(in) | :: | ipiv(*) | |||
| real(kind=dp), | intent(in) | :: | c(*) | |||
| logical(kind=lk), | intent(in) | :: | capply | |||
| integer(kind=ilp), | intent(out) | :: | info | |||
| complex(kind=dp), | intent(out) | :: | work(*) | |||
| real(kind=dp), | intent(out) | :: | rwork(*) |
CLA_HERCOND_C computes the infinity norm condition number of op(A) * inv(diag(C)) where C is a REAL vector.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=sp), | intent(in) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=sp), | intent(in) | :: | af(ldaf,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldaf | |||
| integer(kind=ilp), | intent(in) | :: | ipiv(*) | |||
| real(kind=sp), | intent(in) | :: | c(*) | |||
| logical(kind=lk), | intent(in) | :: | capply | |||
| integer(kind=ilp), | intent(out) | :: | info | |||
| complex(kind=sp), | intent(out) | :: | work(*) | |||
| real(kind=sp), | intent(out) | :: | rwork(*) |
ZLA_HERCOND_C computes the infinity norm condition number of op(A) * inv(diag(C)) where C is a DOUBLE PRECISION vector.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=dp), | intent(in) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=dp), | intent(in) | :: | af(ldaf,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldaf | |||
| integer(kind=ilp), | intent(in) | :: | ipiv(*) | |||
| real(kind=dp), | intent(in) | :: | c(*) | |||
| logical(kind=lk), | intent(in) | :: | capply | |||
| integer(kind=ilp), | intent(out) | :: | info | |||
| complex(kind=dp), | intent(out) | :: | work(*) | |||
| real(kind=dp), | intent(out) | :: | rwork(*) |
LA_HERPVGRW computes the reciprocal pivot growth factor norm(A)/norm(U). The "max absolute element" norm is used. If this is much less than 1, the stability of the LU factorization of the (equilibrated) matrix A could be poor. This also means that the solution X, estimated condition numbers, and error bounds could be unreliable.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | info | |||
| complex(kind=sp), | intent(in) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=sp), | intent(in) | :: | af(ldaf,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldaf | |||
| integer(kind=ilp), | intent(in) | :: | ipiv(*) | |||
| real(kind=sp), | intent(out) | :: | work(*) |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | info | |||
| complex(kind=dp), | intent(in) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=dp), | intent(in) | :: | af(ldaf,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldaf | |||
| integer(kind=ilp), | intent(in) | :: | ipiv(*) | |||
| real(kind=dp), | intent(out) | :: | work(*) |
CLA_HERPVGRW computes the reciprocal pivot growth factor norm(A)/norm(U). The "max absolute element" norm is used. If this is much less than 1, the stability of the LU factorization of the (equilibrated) matrix A could be poor. This also means that the solution X, estimated condition numbers, and error bounds could be unreliable.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | info | |||
| complex(kind=sp), | intent(in) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=sp), | intent(in) | :: | af(ldaf,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldaf | |||
| integer(kind=ilp), | intent(in) | :: | ipiv(*) | |||
| real(kind=sp), | intent(out) | :: | work(*) |
ZLA_HERPVGRW computes the reciprocal pivot growth factor norm(A)/norm(U). The "max absolute element" norm is used. If this is much less than 1, the stability of the LU factorization of the (equilibrated) matrix A could be poor. This also means that the solution X, estimated condition numbers, and error bounds could be unreliable.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | info | |||
| complex(kind=dp), | intent(in) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=dp), | intent(in) | :: | af(ldaf,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldaf | |||
| integer(kind=ilp), | intent(in) | :: | ipiv(*) | |||
| real(kind=dp), | intent(out) | :: | work(*) |
LA_LIN_BERR computes componentwise relative backward error from the formula max(i) ( abs(R(i)) / ( abs(op(A_s))*abs(Y) + abs(B_s) )(i) ) where abs(Z) is the componentwise absolute value of the matrix or vector Z.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nz | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| complex(kind=sp), | intent(in) | :: | res(n,nrhs) | |||
| real(kind=sp), | intent(in) | :: | ayb(n,nrhs) | |||
| real(kind=sp), | intent(out) | :: | berr(nrhs) |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nz | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| real(kind=dp), | intent(in) | :: | res(n,nrhs) | |||
| real(kind=dp), | intent(in) | :: | ayb(n,nrhs) | |||
| real(kind=dp), | intent(out) | :: | berr(nrhs) |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nz | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| real(kind=sp), | intent(in) | :: | res(n,nrhs) | |||
| real(kind=sp), | intent(in) | :: | ayb(n,nrhs) | |||
| real(kind=sp), | intent(out) | :: | berr(nrhs) |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nz | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| complex(kind=dp), | intent(in) | :: | res(n,nrhs) | |||
| real(kind=dp), | intent(in) | :: | ayb(n,nrhs) | |||
| real(kind=dp), | intent(out) | :: | berr(nrhs) |
CLA_LIN_BERR computes componentwise relative backward error from the formula max(i) ( abs(R(i)) / ( abs(op(A_s))*abs(Y) + abs(B_s) )(i) ) where abs(Z) is the componentwise absolute value of the matrix or vector Z.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nz | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| complex(kind=sp), | intent(in) | :: | res(n,nrhs) | |||
| real(kind=sp), | intent(in) | :: | ayb(n,nrhs) | |||
| real(kind=sp), | intent(out) | :: | berr(nrhs) |
DLA_LIN_BERR computes component-wise relative backward error from the formula max(i) ( abs(R(i)) / ( abs(op(A_s))*abs(Y) + abs(B_s) )(i) ) where abs(Z) is the component-wise absolute value of the matrix or vector Z.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nz | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| real(kind=dp), | intent(in) | :: | res(n,nrhs) | |||
| real(kind=dp), | intent(in) | :: | ayb(n,nrhs) | |||
| real(kind=dp), | intent(out) | :: | berr(nrhs) |
SLA_LIN_BERR computes componentwise relative backward error from the formula max(i) ( abs(R(i)) / ( abs(op(A_s))*abs(Y) + abs(B_s) )(i) ) where abs(Z) is the componentwise absolute value of the matrix or vector Z.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nz | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| real(kind=sp), | intent(in) | :: | res(n,nrhs) | |||
| real(kind=sp), | intent(in) | :: | ayb(n,nrhs) | |||
| real(kind=sp), | intent(out) | :: | berr(nrhs) |
ZLA_LIN_BERR computes componentwise relative backward error from the formula max(i) ( abs(R(i)) / ( abs(op(A_s))*abs(Y) + abs(B_s) )(i) ) where abs(Z) is the componentwise absolute value of the matrix or vector Z.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nz | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| complex(kind=dp), | intent(in) | :: | res(n,nrhs) | |||
| real(kind=dp), | intent(in) | :: | ayb(n,nrhs) | |||
| real(kind=dp), | intent(out) | :: | berr(nrhs) |
LA_PORCOND Estimates the Skeel condition number of op(A) * op2(C) where op2 is determined by CMODE as follows CMODE = 1 op2(C) = C CMODE = 0 op2(C) = I CMODE = -1 op2(C) = inv(C) The Skeel condition number cond(A) = norminf( |inv(A)||A| ) is computed by computing scaling factors R such that diag(R)Aop2(C) is row equilibrated and computing the standard infinity-norm condition number.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=dp), | intent(in) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=dp), | intent(in) | :: | af(ldaf,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldaf | |||
| integer(kind=ilp), | intent(in) | :: | cmode | |||
| real(kind=dp), | intent(in) | :: | c(*) | |||
| integer(kind=ilp), | intent(out) | :: | info | |||
| real(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | iwork(*) |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=sp), | intent(in) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=sp), | intent(in) | :: | af(ldaf,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldaf | |||
| integer(kind=ilp), | intent(in) | :: | cmode | |||
| real(kind=sp), | intent(in) | :: | c(*) | |||
| integer(kind=ilp), | intent(out) | :: | info | |||
| real(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | iwork(*) |
DLA_PORCOND Estimates the Skeel condition number of op(A) * op2(C) where op2 is determined by CMODE as follows CMODE = 1 op2(C) = C CMODE = 0 op2(C) = I CMODE = -1 op2(C) = inv(C) The Skeel condition number cond(A) = norminf( |inv(A)||A| ) is computed by computing scaling factors R such that diag(R)Aop2(C) is row equilibrated and computing the standard infinity-norm condition number.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=dp), | intent(in) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=dp), | intent(in) | :: | af(ldaf,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldaf | |||
| integer(kind=ilp), | intent(in) | :: | cmode | |||
| real(kind=dp), | intent(in) | :: | c(*) | |||
| integer(kind=ilp), | intent(out) | :: | info | |||
| real(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | iwork(*) |
SLA_PORCOND Estimates the Skeel condition number of op(A) * op2(C) where op2 is determined by CMODE as follows CMODE = 1 op2(C) = C CMODE = 0 op2(C) = I CMODE = -1 op2(C) = inv(C) The Skeel condition number cond(A) = norminf( |inv(A)||A| ) is computed by computing scaling factors R such that diag(R)Aop2(C) is row equilibrated and computing the standard infinity-norm condition number.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=sp), | intent(in) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=sp), | intent(in) | :: | af(ldaf,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldaf | |||
| integer(kind=ilp), | intent(in) | :: | cmode | |||
| real(kind=sp), | intent(in) | :: | c(*) | |||
| integer(kind=ilp), | intent(out) | :: | info | |||
| real(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | iwork(*) |
LA_PORCOND_C Computes the infinity norm condition number of op(A) * inv(diag(C)) where C is a REAL vector
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=sp), | intent(in) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=sp), | intent(in) | :: | af(ldaf,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldaf | |||
| real(kind=sp), | intent(in) | :: | c(*) | |||
| logical(kind=lk), | intent(in) | :: | capply | |||
| integer(kind=ilp), | intent(out) | :: | info | |||
| complex(kind=sp), | intent(out) | :: | work(*) | |||
| real(kind=sp), | intent(out) | :: | rwork(*) |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=dp), | intent(in) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=dp), | intent(in) | :: | af(ldaf,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldaf | |||
| real(kind=dp), | intent(in) | :: | c(*) | |||
| logical(kind=lk), | intent(in) | :: | capply | |||
| integer(kind=ilp), | intent(out) | :: | info | |||
| complex(kind=dp), | intent(out) | :: | work(*) | |||
| real(kind=dp), | intent(out) | :: | rwork(*) |
CLA_PORCOND_C Computes the infinity norm condition number of op(A) * inv(diag(C)) where C is a REAL vector
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=sp), | intent(in) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=sp), | intent(in) | :: | af(ldaf,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldaf | |||
| real(kind=sp), | intent(in) | :: | c(*) | |||
| logical(kind=lk), | intent(in) | :: | capply | |||
| integer(kind=ilp), | intent(out) | :: | info | |||
| complex(kind=sp), | intent(out) | :: | work(*) | |||
| real(kind=sp), | intent(out) | :: | rwork(*) |
ZLA_PORCOND_C Computes the infinity norm condition number of op(A) * inv(diag(C)) where C is a DOUBLE PRECISION vector
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=dp), | intent(in) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=dp), | intent(in) | :: | af(ldaf,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldaf | |||
| real(kind=dp), | intent(in) | :: | c(*) | |||
| logical(kind=lk), | intent(in) | :: | capply | |||
| integer(kind=ilp), | intent(out) | :: | info | |||
| complex(kind=dp), | intent(out) | :: | work(*) | |||
| real(kind=dp), | intent(out) | :: | rwork(*) |
LA_PORPVGRW computes the reciprocal pivot growth factor norm(A)/norm(U). The "max absolute element" norm is used. If this is much less than 1, the stability of the LU factorization of the (equilibrated) matrix A could be poor. This also means that the solution X, estimated condition numbers, and error bounds could be unreliable.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | ncols | |||
| complex(kind=sp), | intent(in) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=sp), | intent(in) | :: | af(ldaf,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldaf | |||
| real(kind=sp), | intent(out) | :: | work(*) |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | ncols | |||
| real(kind=dp), | intent(in) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=dp), | intent(in) | :: | af(ldaf,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldaf | |||
| real(kind=dp), | intent(out) | :: | work(*) |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | ncols | |||
| real(kind=sp), | intent(in) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=sp), | intent(in) | :: | af(ldaf,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldaf | |||
| real(kind=sp), | intent(out) | :: | work(*) |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | ncols | |||
| complex(kind=dp), | intent(in) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=dp), | intent(in) | :: | af(ldaf,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldaf | |||
| real(kind=dp), | intent(out) | :: | work(*) |
CLA_PORPVGRW computes the reciprocal pivot growth factor norm(A)/norm(U). The "max absolute element" norm is used. If this is much less than 1, the stability of the LU factorization of the (equilibrated) matrix A could be poor. This also means that the solution X, estimated condition numbers, and error bounds could be unreliable.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | ncols | |||
| complex(kind=sp), | intent(in) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=sp), | intent(in) | :: | af(ldaf,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldaf | |||
| real(kind=sp), | intent(out) | :: | work(*) |
DLA_PORPVGRW computes the reciprocal pivot growth factor norm(A)/norm(U). The "max absolute element" norm is used. If this is much less than 1, the stability of the LU factorization of the (equilibrated) matrix A could be poor. This also means that the solution X, estimated condition numbers, and error bounds could be unreliable.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | ncols | |||
| real(kind=dp), | intent(in) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=dp), | intent(in) | :: | af(ldaf,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldaf | |||
| real(kind=dp), | intent(out) | :: | work(*) |
SLA_PORPVGRW computes the reciprocal pivot growth factor norm(A)/norm(U). The "max absolute element" norm is used. If this is much less than 1, the stability of the LU factorization of the (equilibrated) matrix A could be poor. This also means that the solution X, estimated condition numbers, and error bounds could be unreliable.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | ncols | |||
| real(kind=sp), | intent(in) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=sp), | intent(in) | :: | af(ldaf,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldaf | |||
| real(kind=sp), | intent(out) | :: | work(*) |
ZLA_PORPVGRW computes the reciprocal pivot growth factor norm(A)/norm(U). The "max absolute element" norm is used. If this is much less than 1, the stability of the LU factorization of the (equilibrated) matrix A could be poor. This also means that the solution X, estimated condition numbers, and error bounds could be unreliable.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | ncols | |||
| complex(kind=dp), | intent(in) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=dp), | intent(in) | :: | af(ldaf,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldaf | |||
| real(kind=dp), | intent(out) | :: | work(*) |
LA_SYAMV performs the matrix-vector operation y := alphaabs(A)abs(x) + beta*abs(y), where alpha and beta are scalars, x and y are vectors and A is an n by n symmetric matrix. This function is primarily used in calculating error bounds. To protect against underflow during evaluation, components in the resulting vector are perturbed away from zero by (N+1) times the underflow threshold. To prevent unnecessarily large errors for block-structure embedded in general matrices, "symbolically" zero components are not perturbed. A zero entry is considered "symbolic" if all multiplications involved in computing that entry have at least one zero multiplicand.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=sp), | intent(in) | :: | alpha | |||
| complex(kind=sp), | intent(in) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=sp), | intent(in) | :: | x(*) | |||
| integer(kind=ilp), | intent(in) | :: | incx | |||
| real(kind=sp), | intent(in) | :: | beta | |||
| real(kind=sp), | intent(inout) | :: | y(*) | |||
| integer(kind=ilp), | intent(in) | :: | incy |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=dp), | intent(in) | :: | alpha | |||
| real(kind=dp), | intent(in) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=dp), | intent(in) | :: | x(*) | |||
| integer(kind=ilp), | intent(in) | :: | incx | |||
| real(kind=dp), | intent(in) | :: | beta | |||
| real(kind=dp), | intent(inout) | :: | y(*) | |||
| integer(kind=ilp), | intent(in) | :: | incy |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=sp), | intent(in) | :: | alpha | |||
| real(kind=sp), | intent(in) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=sp), | intent(in) | :: | x(*) | |||
| integer(kind=ilp), | intent(in) | :: | incx | |||
| real(kind=sp), | intent(in) | :: | beta | |||
| real(kind=sp), | intent(inout) | :: | y(*) | |||
| integer(kind=ilp), | intent(in) | :: | incy |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=dp), | intent(in) | :: | alpha | |||
| complex(kind=dp), | intent(in) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=dp), | intent(in) | :: | x(*) | |||
| integer(kind=ilp), | intent(in) | :: | incx | |||
| real(kind=dp), | intent(in) | :: | beta | |||
| real(kind=dp), | intent(inout) | :: | y(*) | |||
| integer(kind=ilp), | intent(in) | :: | incy |
CLA_SYAMV performs the matrix-vector operation y := alphaabs(A)abs(x) + beta*abs(y), where alpha and beta are scalars, x and y are vectors and A is an n by n symmetric matrix. This function is primarily used in calculating error bounds. To protect against underflow during evaluation, components in the resulting vector are perturbed away from zero by (N+1) times the underflow threshold. To prevent unnecessarily large errors for block-structure embedded in general matrices, "symbolically" zero components are not perturbed. A zero entry is considered "symbolic" if all multiplications involved in computing that entry have at least one zero multiplicand.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=sp), | intent(in) | :: | alpha | |||
| complex(kind=sp), | intent(in) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=sp), | intent(in) | :: | x(*) | |||
| integer(kind=ilp), | intent(in) | :: | incx | |||
| real(kind=sp), | intent(in) | :: | beta | |||
| real(kind=sp), | intent(inout) | :: | y(*) | |||
| integer(kind=ilp), | intent(in) | :: | incy |
DLA_SYAMV performs the matrix-vector operation y := alphaabs(A)abs(x) + beta*abs(y), where alpha and beta are scalars, x and y are vectors and A is an n by n symmetric matrix. This function is primarily used in calculating error bounds. To protect against underflow during evaluation, components in the resulting vector are perturbed away from zero by (N+1) times the underflow threshold. To prevent unnecessarily large errors for block-structure embedded in general matrices, "symbolically" zero components are not perturbed. A zero entry is considered "symbolic" if all multiplications involved in computing that entry have at least one zero multiplicand.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=dp), | intent(in) | :: | alpha | |||
| real(kind=dp), | intent(in) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=dp), | intent(in) | :: | x(*) | |||
| integer(kind=ilp), | intent(in) | :: | incx | |||
| real(kind=dp), | intent(in) | :: | beta | |||
| real(kind=dp), | intent(inout) | :: | y(*) | |||
| integer(kind=ilp), | intent(in) | :: | incy |
SLA_SYAMV performs the matrix-vector operation y := alphaabs(A)abs(x) + beta*abs(y), where alpha and beta are scalars, x and y are vectors and A is an n by n symmetric matrix. This function is primarily used in calculating error bounds. To protect against underflow during evaluation, components in the resulting vector are perturbed away from zero by (N+1) times the underflow threshold. To prevent unnecessarily large errors for block-structure embedded in general matrices, "symbolically" zero components are not perturbed. A zero entry is considered "symbolic" if all multiplications involved in computing that entry have at least one zero multiplicand.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=sp), | intent(in) | :: | alpha | |||
| real(kind=sp), | intent(in) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=sp), | intent(in) | :: | x(*) | |||
| integer(kind=ilp), | intent(in) | :: | incx | |||
| real(kind=sp), | intent(in) | :: | beta | |||
| real(kind=sp), | intent(inout) | :: | y(*) | |||
| integer(kind=ilp), | intent(in) | :: | incy |
ZLA_SYAMV performs the matrix-vector operation y := alphaabs(A)abs(x) + beta*abs(y), where alpha and beta are scalars, x and y are vectors and A is an n by n symmetric matrix. This function is primarily used in calculating error bounds. To protect against underflow during evaluation, components in the resulting vector are perturbed away from zero by (N+1) times the underflow threshold. To prevent unnecessarily large errors for block-structure embedded in general matrices, "symbolically" zero components are not perturbed. A zero entry is considered "symbolic" if all multiplications involved in computing that entry have at least one zero multiplicand.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=dp), | intent(in) | :: | alpha | |||
| complex(kind=dp), | intent(in) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=dp), | intent(in) | :: | x(*) | |||
| integer(kind=ilp), | intent(in) | :: | incx | |||
| real(kind=dp), | intent(in) | :: | beta | |||
| real(kind=dp), | intent(inout) | :: | y(*) | |||
| integer(kind=ilp), | intent(in) | :: | incy |
LA_SYRCOND estimates the Skeel condition number of op(A) * op2(C) where op2 is determined by CMODE as follows CMODE = 1 op2(C) = C CMODE = 0 op2(C) = I CMODE = -1 op2(C) = inv(C) The Skeel condition number cond(A) = norminf( |inv(A)||A| ) is computed by computing scaling factors R such that diag(R)Aop2(C) is row equilibrated and computing the standard infinity-norm condition number.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=dp), | intent(in) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=dp), | intent(in) | :: | af(ldaf,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldaf | |||
| integer(kind=ilp), | intent(in) | :: | ipiv(*) | |||
| integer(kind=ilp), | intent(in) | :: | cmode | |||
| real(kind=dp), | intent(in) | :: | c(*) | |||
| integer(kind=ilp), | intent(out) | :: | info | |||
| real(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | iwork(*) |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=sp), | intent(in) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=sp), | intent(in) | :: | af(ldaf,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldaf | |||
| integer(kind=ilp), | intent(in) | :: | ipiv(*) | |||
| integer(kind=ilp), | intent(in) | :: | cmode | |||
| real(kind=sp), | intent(in) | :: | c(*) | |||
| integer(kind=ilp), | intent(out) | :: | info | |||
| real(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | iwork(*) |
DLA_SYRCOND estimates the Skeel condition number of op(A) * op2(C) where op2 is determined by CMODE as follows CMODE = 1 op2(C) = C CMODE = 0 op2(C) = I CMODE = -1 op2(C) = inv(C) The Skeel condition number cond(A) = norminf( |inv(A)||A| ) is computed by computing scaling factors R such that diag(R)Aop2(C) is row equilibrated and computing the standard infinity-norm condition number.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=dp), | intent(in) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=dp), | intent(in) | :: | af(ldaf,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldaf | |||
| integer(kind=ilp), | intent(in) | :: | ipiv(*) | |||
| integer(kind=ilp), | intent(in) | :: | cmode | |||
| real(kind=dp), | intent(in) | :: | c(*) | |||
| integer(kind=ilp), | intent(out) | :: | info | |||
| real(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | iwork(*) |
SLA_SYRCOND estimates the Skeel condition number of op(A) * op2(C) where op2 is determined by CMODE as follows CMODE = 1 op2(C) = C CMODE = 0 op2(C) = I CMODE = -1 op2(C) = inv(C) The Skeel condition number cond(A) = norminf( |inv(A)||A| ) is computed by computing scaling factors R such that diag(R)Aop2(C) is row equilibrated and computing the standard infinity-norm condition number.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=sp), | intent(in) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=sp), | intent(in) | :: | af(ldaf,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldaf | |||
| integer(kind=ilp), | intent(in) | :: | ipiv(*) | |||
| integer(kind=ilp), | intent(in) | :: | cmode | |||
| real(kind=sp), | intent(in) | :: | c(*) | |||
| integer(kind=ilp), | intent(out) | :: | info | |||
| real(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | iwork(*) |
LA_SYRCOND_C Computes the infinity norm condition number of op(A) * inv(diag(C)) where C is a REAL vector.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=sp), | intent(in) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=sp), | intent(in) | :: | af(ldaf,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldaf | |||
| integer(kind=ilp), | intent(in) | :: | ipiv(*) | |||
| real(kind=sp), | intent(in) | :: | c(*) | |||
| logical(kind=lk), | intent(in) | :: | capply | |||
| integer(kind=ilp), | intent(out) | :: | info | |||
| complex(kind=sp), | intent(out) | :: | work(*) | |||
| real(kind=sp), | intent(out) | :: | rwork(*) |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=dp), | intent(in) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=dp), | intent(in) | :: | af(ldaf,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldaf | |||
| integer(kind=ilp), | intent(in) | :: | ipiv(*) | |||
| real(kind=dp), | intent(in) | :: | c(*) | |||
| logical(kind=lk), | intent(in) | :: | capply | |||
| integer(kind=ilp), | intent(out) | :: | info | |||
| complex(kind=dp), | intent(out) | :: | work(*) | |||
| real(kind=dp), | intent(out) | :: | rwork(*) |
CLA_SYRCOND_C Computes the infinity norm condition number of op(A) * inv(diag(C)) where C is a REAL vector.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=sp), | intent(in) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=sp), | intent(in) | :: | af(ldaf,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldaf | |||
| integer(kind=ilp), | intent(in) | :: | ipiv(*) | |||
| real(kind=sp), | intent(in) | :: | c(*) | |||
| logical(kind=lk), | intent(in) | :: | capply | |||
| integer(kind=ilp), | intent(out) | :: | info | |||
| complex(kind=sp), | intent(out) | :: | work(*) | |||
| real(kind=sp), | intent(out) | :: | rwork(*) |
ZLA_SYRCOND_C Computes the infinity norm condition number of op(A) * inv(diag(C)) where C is a DOUBLE PRECISION vector.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=dp), | intent(in) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=dp), | intent(in) | :: | af(ldaf,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldaf | |||
| integer(kind=ilp), | intent(in) | :: | ipiv(*) | |||
| real(kind=dp), | intent(in) | :: | c(*) | |||
| logical(kind=lk), | intent(in) | :: | capply | |||
| integer(kind=ilp), | intent(out) | :: | info | |||
| complex(kind=dp), | intent(out) | :: | work(*) | |||
| real(kind=dp), | intent(out) | :: | rwork(*) |
LA_SYRPVGRW computes the reciprocal pivot growth factor norm(A)/norm(U). The "max absolute element" norm is used. If this is much less than 1, the stability of the LU factorization of the (equilibrated) matrix A could be poor. This also means that the solution X, estimated condition numbers, and error bounds could be unreliable.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | info | |||
| complex(kind=sp), | intent(in) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=sp), | intent(in) | :: | af(ldaf,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldaf | |||
| integer(kind=ilp), | intent(in) | :: | ipiv(*) | |||
| real(kind=sp), | intent(out) | :: | work(*) |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | info | |||
| real(kind=dp), | intent(in) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=dp), | intent(in) | :: | af(ldaf,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldaf | |||
| integer(kind=ilp), | intent(in) | :: | ipiv(*) | |||
| real(kind=dp), | intent(out) | :: | work(*) |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | info | |||
| real(kind=sp), | intent(in) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=sp), | intent(in) | :: | af(ldaf,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldaf | |||
| integer(kind=ilp), | intent(in) | :: | ipiv(*) | |||
| real(kind=sp), | intent(out) | :: | work(*) |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | info | |||
| complex(kind=dp), | intent(in) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=dp), | intent(in) | :: | af(ldaf,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldaf | |||
| integer(kind=ilp), | intent(in) | :: | ipiv(*) | |||
| real(kind=dp), | intent(out) | :: | work(*) |
CLA_SYRPVGRW computes the reciprocal pivot growth factor norm(A)/norm(U). The "max absolute element" norm is used. If this is much less than 1, the stability of the LU factorization of the (equilibrated) matrix A could be poor. This also means that the solution X, estimated condition numbers, and error bounds could be unreliable.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | info | |||
| complex(kind=sp), | intent(in) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=sp), | intent(in) | :: | af(ldaf,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldaf | |||
| integer(kind=ilp), | intent(in) | :: | ipiv(*) | |||
| real(kind=sp), | intent(out) | :: | work(*) |
DLA_SYRPVGRW computes the reciprocal pivot growth factor norm(A)/norm(U). The "max absolute element" norm is used. If this is much less than 1, the stability of the LU factorization of the (equilibrated) matrix A could be poor. This also means that the solution X, estimated condition numbers, and error bounds could be unreliable.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | info | |||
| real(kind=dp), | intent(in) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=dp), | intent(in) | :: | af(ldaf,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldaf | |||
| integer(kind=ilp), | intent(in) | :: | ipiv(*) | |||
| real(kind=dp), | intent(out) | :: | work(*) |
SLA_SYRPVGRW computes the reciprocal pivot growth factor norm(A)/norm(U). The "max absolute element" norm is used. If this is much less than 1, the stability of the LU factorization of the (equilibrated) matrix A could be poor. This also means that the solution X, estimated condition numbers, and error bounds could be unreliable.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | info | |||
| real(kind=sp), | intent(in) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=sp), | intent(in) | :: | af(ldaf,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldaf | |||
| integer(kind=ilp), | intent(in) | :: | ipiv(*) | |||
| real(kind=sp), | intent(out) | :: | work(*) |
ZLA_SYRPVGRW computes the reciprocal pivot growth factor norm(A)/norm(U). The "max absolute element" norm is used. If this is much less than 1, the stability of the LU factorization of the (equilibrated) matrix A could be poor. This also means that the solution X, estimated condition numbers, and error bounds could be unreliable.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | info | |||
| complex(kind=dp), | intent(in) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=dp), | intent(in) | :: | af(ldaf,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldaf | |||
| integer(kind=ilp), | intent(in) | :: | ipiv(*) | |||
| real(kind=dp), | intent(out) | :: | work(*) |
LA_WWADDW adds a vector W into a doubled-single vector (X, Y). This works for all extant IBM's hex and binary floating point arithmetic, but not for decimal.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=sp), | intent(inout) | :: | x(*) | |||
| complex(kind=sp), | intent(inout) | :: | y(*) | |||
| complex(kind=sp), | intent(in) | :: | w(*) |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=dp), | intent(inout) | :: | x(*) | |||
| real(kind=dp), | intent(inout) | :: | y(*) | |||
| real(kind=dp), | intent(in) | :: | w(*) |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=sp), | intent(inout) | :: | x(*) | |||
| real(kind=sp), | intent(inout) | :: | y(*) | |||
| real(kind=sp), | intent(in) | :: | w(*) |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=dp), | intent(inout) | :: | x(*) | |||
| complex(kind=dp), | intent(inout) | :: | y(*) | |||
| complex(kind=dp), | intent(in) | :: | w(*) |
CLA_WWADDW adds a vector W into a doubled-single vector (X, Y). This works for all extant IBM's hex and binary floating point arithmetic, but not for decimal.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=sp), | intent(inout) | :: | x(*) | |||
| complex(kind=sp), | intent(inout) | :: | y(*) | |||
| complex(kind=sp), | intent(in) | :: | w(*) |
DLA_WWADDW adds a vector W into a doubled-single vector (X, Y). This works for all extant IBM's hex and binary floating point arithmetic, but not for decimal.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=dp), | intent(inout) | :: | x(*) | |||
| real(kind=dp), | intent(inout) | :: | y(*) | |||
| real(kind=dp), | intent(in) | :: | w(*) |
SLA_WWADDW adds a vector W into a doubled-single vector (X, Y). This works for all extant IBM's hex and binary floating point arithmetic, but not for decimal.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=sp), | intent(inout) | :: | x(*) | |||
| real(kind=sp), | intent(inout) | :: | y(*) | |||
| real(kind=sp), | intent(in) | :: | w(*) |
ZLA_WWADDW adds a vector W into a doubled-single vector (X, Y). This works for all extant IBM's hex and binary floating point arithmetic, but not for decimal.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=dp), | intent(inout) | :: | x(*) | |||
| complex(kind=dp), | intent(inout) | :: | y(*) | |||
| complex(kind=dp), | intent(in) | :: | w(*) |
LABAD takes as input the values computed by DLAMCH for underflow and overflow, and returns the square root of each of these values if the log of LARGE is sufficiently large. This subroutine is intended to identify machines with a large exponent range, such as the Crays, and redefine the underflow and overflow limits to be the square roots of the values computed by DLAMCH. This subroutine is needed because DLAMCH does not compensate for poor arithmetic in the upper half of the exponent range, as is found on a Cray.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| real(kind=dp), | intent(inout) | :: | small | |||
| real(kind=dp), | intent(inout) | :: | large |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| real(kind=sp), | intent(inout) | :: | small | |||
| real(kind=sp), | intent(inout) | :: | large |
DLABAD takes as input the values computed by DLAMCH for underflow and overflow, and returns the square root of each of these values if the log of LARGE is sufficiently large. This subroutine is intended to identify machines with a large exponent range, such as the Crays, and redefine the underflow and overflow limits to be the square roots of the values computed by DLAMCH. This subroutine is needed because DLAMCH does not compensate for poor arithmetic in the upper half of the exponent range, as is found on a Cray.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| real(kind=dp), | intent(inout) | :: | small | |||
| real(kind=dp), | intent(inout) | :: | large |
SLABAD takes as input the values computed by SLAMCH for underflow and overflow, and returns the square root of each of these values if the log of LARGE is sufficiently large. This subroutine is intended to identify machines with a large exponent range, such as the Crays, and redefine the underflow and overflow limits to be the square roots of the values computed by SLAMCH. This subroutine is needed because SLAMCH does not compensate for poor arithmetic in the upper half of the exponent range, as is found on a Cray.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| real(kind=sp), | intent(inout) | :: | small | |||
| real(kind=sp), | intent(inout) | :: | large |
LABRD reduces the first NB rows and columns of a complex general m by n matrix A to upper or lower real bidiagonal form by a unitary transformation Q**H * A * P, and returns the matrices X and Y which are needed to apply the transformation to the unreduced part of A. If m >= n, A is reduced to upper bidiagonal form; if m < n, to lower bidiagonal form. This is an auxiliary routine called by CGEBRD
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nb | |||
| complex(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=sp), | intent(out) | :: | d(*) | |||
| real(kind=sp), | intent(out) | :: | e(*) | |||
| complex(kind=sp), | intent(out) | :: | tauq(*) | |||
| complex(kind=sp), | intent(out) | :: | taup(*) | |||
| complex(kind=sp), | intent(out) | :: | x(ldx,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldx | |||
| complex(kind=sp), | intent(out) | :: | y(ldy,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldy |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nb | |||
| real(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=dp), | intent(out) | :: | d(*) | |||
| real(kind=dp), | intent(out) | :: | e(*) | |||
| real(kind=dp), | intent(out) | :: | tauq(*) | |||
| real(kind=dp), | intent(out) | :: | taup(*) | |||
| real(kind=dp), | intent(out) | :: | x(ldx,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldx | |||
| real(kind=dp), | intent(out) | :: | y(ldy,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldy |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nb | |||
| real(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=sp), | intent(out) | :: | d(*) | |||
| real(kind=sp), | intent(out) | :: | e(*) | |||
| real(kind=sp), | intent(out) | :: | tauq(*) | |||
| real(kind=sp), | intent(out) | :: | taup(*) | |||
| real(kind=sp), | intent(out) | :: | x(ldx,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldx | |||
| real(kind=sp), | intent(out) | :: | y(ldy,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldy |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nb | |||
| complex(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=dp), | intent(out) | :: | d(*) | |||
| real(kind=dp), | intent(out) | :: | e(*) | |||
| complex(kind=dp), | intent(out) | :: | tauq(*) | |||
| complex(kind=dp), | intent(out) | :: | taup(*) | |||
| complex(kind=dp), | intent(out) | :: | x(ldx,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldx | |||
| complex(kind=dp), | intent(out) | :: | y(ldy,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldy |
CLABRD reduces the first NB rows and columns of a complex general m by n matrix A to upper or lower real bidiagonal form by a unitary transformation Q**H * A * P, and returns the matrices X and Y which are needed to apply the transformation to the unreduced part of A. If m >= n, A is reduced to upper bidiagonal form; if m < n, to lower bidiagonal form. This is an auxiliary routine called by CGEBRD
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nb | |||
| complex(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=sp), | intent(out) | :: | d(*) | |||
| real(kind=sp), | intent(out) | :: | e(*) | |||
| complex(kind=sp), | intent(out) | :: | tauq(*) | |||
| complex(kind=sp), | intent(out) | :: | taup(*) | |||
| complex(kind=sp), | intent(out) | :: | x(ldx,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldx | |||
| complex(kind=sp), | intent(out) | :: | y(ldy,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldy |
DLABRD reduces the first NB rows and columns of a real general m by n matrix A to upper or lower bidiagonal form by an orthogonal transformation Q**T * A * P, and returns the matrices X and Y which are needed to apply the transformation to the unreduced part of A. If m >= n, A is reduced to upper bidiagonal form; if m < n, to lower bidiagonal form. This is an auxiliary routine called by DGEBRD
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nb | |||
| real(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=dp), | intent(out) | :: | d(*) | |||
| real(kind=dp), | intent(out) | :: | e(*) | |||
| real(kind=dp), | intent(out) | :: | tauq(*) | |||
| real(kind=dp), | intent(out) | :: | taup(*) | |||
| real(kind=dp), | intent(out) | :: | x(ldx,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldx | |||
| real(kind=dp), | intent(out) | :: | y(ldy,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldy |
SLABRD reduces the first NB rows and columns of a real general m by n matrix A to upper or lower bidiagonal form by an orthogonal transformation Q**T * A * P, and returns the matrices X and Y which are needed to apply the transformation to the unreduced part of A. If m >= n, A is reduced to upper bidiagonal form; if m < n, to lower bidiagonal form. This is an auxiliary routine called by SGEBRD
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nb | |||
| real(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=sp), | intent(out) | :: | d(*) | |||
| real(kind=sp), | intent(out) | :: | e(*) | |||
| real(kind=sp), | intent(out) | :: | tauq(*) | |||
| real(kind=sp), | intent(out) | :: | taup(*) | |||
| real(kind=sp), | intent(out) | :: | x(ldx,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldx | |||
| real(kind=sp), | intent(out) | :: | y(ldy,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldy |
ZLABRD reduces the first NB rows and columns of a complex general m by n matrix A to upper or lower real bidiagonal form by a unitary transformation Q**H * A * P, and returns the matrices X and Y which are needed to apply the transformation to the unreduced part of A. If m >= n, A is reduced to upper bidiagonal form; if m < n, to lower bidiagonal form. This is an auxiliary routine called by ZGEBRD
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nb | |||
| complex(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=dp), | intent(out) | :: | d(*) | |||
| real(kind=dp), | intent(out) | :: | e(*) | |||
| complex(kind=dp), | intent(out) | :: | tauq(*) | |||
| complex(kind=dp), | intent(out) | :: | taup(*) | |||
| complex(kind=dp), | intent(out) | :: | x(ldx,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldx | |||
| complex(kind=dp), | intent(out) | :: | y(ldy,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldy |
LACGV conjugates a complex vector of length N.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=sp), | intent(inout) | :: | x(*) | |||
| integer(kind=ilp), | intent(in) | :: | incx |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=dp), | intent(inout) | :: | x(*) | |||
| integer(kind=ilp), | intent(in) | :: | incx |
CLACGV conjugates a complex vector of length N.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=sp), | intent(inout) | :: | x(*) | |||
| integer(kind=ilp), | intent(in) | :: | incx |
ZLACGV conjugates a complex vector of length N.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=dp), | intent(inout) | :: | x(*) | |||
| integer(kind=ilp), | intent(in) | :: | incx |
LACON estimates the 1-norm of a square, complex matrix A. Reverse communication is used for evaluating matrix-vector products.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=sp), | intent(out) | :: | v(n) | |||
| complex(kind=sp), | intent(inout) | :: | x(n) | |||
| real(kind=sp), | intent(inout) | :: | est | |||
| integer(kind=ilp), | intent(inout) | :: | kase |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=dp), | intent(out) | :: | v(*) | |||
| real(kind=dp), | intent(inout) | :: | x(*) | |||
| integer(kind=ilp), | intent(out) | :: | isgn(*) | |||
| real(kind=dp), | intent(inout) | :: | est | |||
| integer(kind=ilp), | intent(inout) | :: | kase |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=sp), | intent(out) | :: | v(*) | |||
| real(kind=sp), | intent(inout) | :: | x(*) | |||
| integer(kind=ilp), | intent(out) | :: | isgn(*) | |||
| real(kind=sp), | intent(inout) | :: | est | |||
| integer(kind=ilp), | intent(inout) | :: | kase |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=dp), | intent(out) | :: | v(n) | |||
| complex(kind=dp), | intent(inout) | :: | x(n) | |||
| real(kind=dp), | intent(inout) | :: | est | |||
| integer(kind=ilp), | intent(inout) | :: | kase |
CLACON estimates the 1-norm of a square, complex matrix A. Reverse communication is used for evaluating matrix-vector products.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=sp), | intent(out) | :: | v(n) | |||
| complex(kind=sp), | intent(inout) | :: | x(n) | |||
| real(kind=sp), | intent(inout) | :: | est | |||
| integer(kind=ilp), | intent(inout) | :: | kase |
DLACON estimates the 1-norm of a square, real matrix A. Reverse communication is used for evaluating matrix-vector products.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=dp), | intent(out) | :: | v(*) | |||
| real(kind=dp), | intent(inout) | :: | x(*) | |||
| integer(kind=ilp), | intent(out) | :: | isgn(*) | |||
| real(kind=dp), | intent(inout) | :: | est | |||
| integer(kind=ilp), | intent(inout) | :: | kase |
SLACON estimates the 1-norm of a square, real matrix A. Reverse communication is used for evaluating matrix-vector products.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=sp), | intent(out) | :: | v(*) | |||
| real(kind=sp), | intent(inout) | :: | x(*) | |||
| integer(kind=ilp), | intent(out) | :: | isgn(*) | |||
| real(kind=sp), | intent(inout) | :: | est | |||
| integer(kind=ilp), | intent(inout) | :: | kase |
ZLACON estimates the 1-norm of a square, complex matrix A. Reverse communication is used for evaluating matrix-vector products.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=dp), | intent(out) | :: | v(n) | |||
| complex(kind=dp), | intent(inout) | :: | x(n) | |||
| real(kind=dp), | intent(inout) | :: | est | |||
| integer(kind=ilp), | intent(inout) | :: | kase |
LACPY copies all or part of a two-dimensional matrix A to another matrix B.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=sp), | intent(in) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=sp), | intent(out) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=dp), | intent(in) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=dp), | intent(out) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=sp), | intent(in) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=sp), | intent(out) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=dp), | intent(in) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=dp), | intent(out) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb |
CLACPY copies all or part of a two-dimensional matrix A to another matrix B.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=sp), | intent(in) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=sp), | intent(out) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb |
DLACPY copies all or part of a two-dimensional matrix A to another matrix B.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=dp), | intent(in) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=dp), | intent(out) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb |
SLACPY copies all or part of a two-dimensional matrix A to another matrix B.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=sp), | intent(in) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=sp), | intent(out) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb |
ZLACPY copies all or part of a two-dimensional matrix A to another matrix B.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=dp), | intent(in) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=dp), | intent(out) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb |
LACRM performs a very simple matrix-matrix multiplication: C := A * B, where A is M by N and complex; B is N by N and real; C is M by N and complex.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=sp), | intent(in) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=sp), | intent(in) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| complex(kind=sp), | intent(out) | :: | c(ldc,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldc | |||
| real(kind=sp), | intent(out) | :: | rwork(*) |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=dp), | intent(in) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=dp), | intent(in) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| complex(kind=dp), | intent(out) | :: | c(ldc,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldc | |||
| real(kind=dp), | intent(out) | :: | rwork(*) |
CLACRM performs a very simple matrix-matrix multiplication: C := A * B, where A is M by N and complex; B is N by N and real; C is M by N and complex.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=sp), | intent(in) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=sp), | intent(in) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| complex(kind=sp), | intent(out) | :: | c(ldc,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldc | |||
| real(kind=sp), | intent(out) | :: | rwork(*) |
ZLACRM performs a very simple matrix-matrix multiplication: C := A * B, where A is M by N and complex; B is N by N and real; C is M by N and complex.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=dp), | intent(in) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=dp), | intent(in) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| complex(kind=dp), | intent(out) | :: | c(ldc,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldc | |||
| real(kind=dp), | intent(out) | :: | rwork(*) |
LACRT performs the operation ( c s )( x ) ==> ( x ) ( -s c )( y ) ( y ) where c and s are complex and the vectors x and y are complex.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=sp), | intent(inout) | :: | cx(*) | |||
| integer(kind=ilp), | intent(in) | :: | incx | |||
| complex(kind=sp), | intent(inout) | :: | cy(*) | |||
| integer(kind=ilp), | intent(in) | :: | incy | |||
| complex(kind=sp), | intent(in) | :: | c | |||
| complex(kind=sp), | intent(in) | :: | s |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=dp), | intent(inout) | :: | cx(*) | |||
| integer(kind=ilp), | intent(in) | :: | incx | |||
| complex(kind=dp), | intent(inout) | :: | cy(*) | |||
| integer(kind=ilp), | intent(in) | :: | incy | |||
| complex(kind=dp), | intent(in) | :: | c | |||
| complex(kind=dp), | intent(in) | :: | s |
CLACRT performs the operation ( c s )( x ) ==> ( x ) ( -s c )( y ) ( y ) where c and s are complex and the vectors x and y are complex.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=sp), | intent(inout) | :: | cx(*) | |||
| integer(kind=ilp), | intent(in) | :: | incx | |||
| complex(kind=sp), | intent(inout) | :: | cy(*) | |||
| integer(kind=ilp), | intent(in) | :: | incy | |||
| complex(kind=sp), | intent(in) | :: | c | |||
| complex(kind=sp), | intent(in) | :: | s |
ZLACRT performs the operation ( c s )( x ) ==> ( x ) ( -s c )( y ) ( y ) where c and s are complex and the vectors x and y are complex.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=dp), | intent(inout) | :: | cx(*) | |||
| integer(kind=ilp), | intent(in) | :: | incx | |||
| complex(kind=dp), | intent(inout) | :: | cy(*) | |||
| integer(kind=ilp), | intent(in) | :: | incy | |||
| complex(kind=dp), | intent(in) | :: | c | |||
| complex(kind=dp), | intent(in) | :: | s |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| real(kind=dp), | intent(inout) | :: | a | |||
| real(kind=dp), | intent(in) | :: | b | |||
| real(kind=dp), | intent(in) | :: | c | |||
| real(kind=dp), | intent(in) | :: | d | |||
| real(kind=dp), | intent(out) | :: | p | |||
| real(kind=dp), | intent(out) | :: | q |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| real(kind=sp), | intent(inout) | :: | a | |||
| real(kind=sp), | intent(in) | :: | b | |||
| real(kind=sp), | intent(in) | :: | c | |||
| real(kind=sp), | intent(in) | :: | d | |||
| real(kind=sp), | intent(out) | :: | p | |||
| real(kind=sp), | intent(out) | :: | q |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| real(kind=dp), | intent(inout) | :: | a | |||
| real(kind=dp), | intent(in) | :: | b | |||
| real(kind=dp), | intent(in) | :: | c | |||
| real(kind=dp), | intent(in) | :: | d | |||
| real(kind=dp), | intent(out) | :: | p | |||
| real(kind=dp), | intent(out) | :: | q |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| real(kind=sp), | intent(inout) | :: | a | |||
| real(kind=sp), | intent(in) | :: | b | |||
| real(kind=sp), | intent(in) | :: | c | |||
| real(kind=sp), | intent(in) | :: | d | |||
| real(kind=sp), | intent(out) | :: | p | |||
| real(kind=sp), | intent(out) | :: | q |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| real(kind=dp), | intent(in) | :: | a | |||
| real(kind=dp), | intent(in) | :: | b | |||
| real(kind=dp), | intent(in) | :: | c | |||
| real(kind=dp), | intent(in) | :: | d | |||
| real(kind=dp), | intent(in) | :: | r | |||
| real(kind=dp), | intent(in) | :: | t |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| real(kind=sp), | intent(in) | :: | a | |||
| real(kind=sp), | intent(in) | :: | b | |||
| real(kind=sp), | intent(in) | :: | c | |||
| real(kind=sp), | intent(in) | :: | d | |||
| real(kind=sp), | intent(in) | :: | r | |||
| real(kind=sp), | intent(in) | :: | t |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| real(kind=dp), | intent(in) | :: | a | |||
| real(kind=dp), | intent(in) | :: | b | |||
| real(kind=dp), | intent(in) | :: | c | |||
| real(kind=dp), | intent(in) | :: | d | |||
| real(kind=dp), | intent(in) | :: | r | |||
| real(kind=dp), | intent(in) | :: | t |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| real(kind=sp), | intent(in) | :: | a | |||
| real(kind=sp), | intent(in) | :: | b | |||
| real(kind=sp), | intent(in) | :: | c | |||
| real(kind=sp), | intent(in) | :: | d | |||
| real(kind=sp), | intent(in) | :: | r | |||
| real(kind=sp), | intent(in) | :: | t |
LADIV_F := X / Y, where X and Y are complex. The computation of X / Y will not overflow on an intermediary step unless the results overflows.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| complex(kind=sp), | intent(in) | :: | x | |||
| complex(kind=sp), | intent(in) | :: | y |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| complex(kind=dp), | intent(in) | :: | x | |||
| complex(kind=dp), | intent(in) | :: | y |
CLADIV := X / Y, where X and Y are complex. The computation of X / Y will not overflow on an intermediary step unless the results overflows.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| complex(kind=sp), | intent(in) | :: | x | |||
| complex(kind=sp), | intent(in) | :: | y |
ZLADIV := X / Y, where X and Y are complex. The computation of X / Y will not overflow on an intermediary step unless the results overflows.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| complex(kind=dp), | intent(in) | :: | x | |||
| complex(kind=dp), | intent(in) | :: | y |
LADIV_S performs complex division in real arithmetic a + ib p + iq = --------- c + i*d The algorithm is due to Michael Baudin and Robert L. Smith and can be found in the paper "A Robust Complex Division in Scilab"
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| real(kind=dp), | intent(in) | :: | a | |||
| real(kind=dp), | intent(in) | :: | b | |||
| real(kind=dp), | intent(in) | :: | c | |||
| real(kind=dp), | intent(in) | :: | d | |||
| real(kind=dp), | intent(out) | :: | p | |||
| real(kind=dp), | intent(out) | :: | q |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| real(kind=sp), | intent(in) | :: | a | |||
| real(kind=sp), | intent(in) | :: | b | |||
| real(kind=sp), | intent(in) | :: | c | |||
| real(kind=sp), | intent(in) | :: | d | |||
| real(kind=sp), | intent(out) | :: | p | |||
| real(kind=sp), | intent(out) | :: | q |
DLADIV performs complex division in real arithmetic a + ib p + iq = --------- c + i*d The algorithm is due to Michael Baudin and Robert L. Smith and can be found in the paper "A Robust Complex Division in Scilab"
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| real(kind=dp), | intent(in) | :: | a | |||
| real(kind=dp), | intent(in) | :: | b | |||
| real(kind=dp), | intent(in) | :: | c | |||
| real(kind=dp), | intent(in) | :: | d | |||
| real(kind=dp), | intent(out) | :: | p | |||
| real(kind=dp), | intent(out) | :: | q |
SLADIV performs complex division in real arithmetic a + ib p + iq = --------- c + i*d The algorithm is due to Michael Baudin and Robert L. Smith and can be found in the paper "A Robust Complex Division in Scilab"
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| real(kind=sp), | intent(in) | :: | a | |||
| real(kind=sp), | intent(in) | :: | b | |||
| real(kind=sp), | intent(in) | :: | c | |||
| real(kind=sp), | intent(in) | :: | d | |||
| real(kind=sp), | intent(out) | :: | p | |||
| real(kind=sp), | intent(out) | :: | q |
LAEBZ contains the iteration loops which compute and use the function N(w), which is the count of eigenvalues of a symmetric tridiagonal matrix T less than or equal to its argument w. It performs a choice of two types of loops: IJOB=1, followed by IJOB=2: It takes as input a list of intervals and returns a list of sufficiently small intervals whose union contains the same eigenvalues as the union of the original intervals. The input intervals are (AB(j,1),AB(j,2)], j=1,...,MINP. The output interval (AB(j,1),AB(j,2)] will contain eigenvalues NAB(j,1)+1,...,NAB(j,2), where 1 <= j <= MOUT. IJOB=3: It performs a binary search in each input interval (AB(j,1),AB(j,2)] for a point w(j) such that N(w(j))=NVAL(j), and uses C(j) as the starting point of the search. If such a w(j) is found, then on output AB(j,1)=AB(j,2)=w. If no such w(j) is found, then on output (AB(j,1),AB(j,2)] will be a small interval containing the point where N(w) jumps through NVAL(j), unless that point lies outside the initial interval. Note that the intervals are in all cases half-open intervals, i.e., of the form (a,b] , which includes b but not a . To avoid underflow, the matrix should be scaled so that its largest element is no greater than overflow(1/2) * underflow(1/4) in absolute value. To assure the most accurate computation of small eigenvalues, the matrix should be scaled to be not much smaller than that, either. See W. Kahan "Accurate Eigenvalues of a Symmetric Tridiagonal Matrix", Report CS41, Computer Science Dept., Stanford University, July 21, 1966 Note: the arguments are, in general, not checked for unreasonable values.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | ijob | |||
| integer(kind=ilp), | intent(in) | :: | nitmax | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | mmax | |||
| integer(kind=ilp), | intent(in) | :: | minp | |||
| integer(kind=ilp), | intent(in) | :: | nbmin | |||
| real(kind=dp), | intent(in) | :: | abstol | |||
| real(kind=dp), | intent(in) | :: | reltol | |||
| real(kind=dp), | intent(in) | :: | pivmin | |||
| real(kind=dp), | intent(in) | :: | d(*) | |||
| real(kind=dp), | intent(in) | :: | e(*) | |||
| real(kind=dp), | intent(in) | :: | e2(*) | |||
| integer(kind=ilp), | intent(inout) | :: | nval(*) | |||
| real(kind=dp), | intent(inout) | :: | ab(mmax,*) | |||
| real(kind=dp), | intent(inout) | :: | c(*) | |||
| integer(kind=ilp), | intent(out) | :: | mout | |||
| integer(kind=ilp), | intent(inout) | :: | nab(mmax,*) | |||
| real(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | iwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | ijob | |||
| integer(kind=ilp), | intent(in) | :: | nitmax | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | mmax | |||
| integer(kind=ilp), | intent(in) | :: | minp | |||
| integer(kind=ilp), | intent(in) | :: | nbmin | |||
| real(kind=sp), | intent(in) | :: | abstol | |||
| real(kind=sp), | intent(in) | :: | reltol | |||
| real(kind=sp), | intent(in) | :: | pivmin | |||
| real(kind=sp), | intent(in) | :: | d(*) | |||
| real(kind=sp), | intent(in) | :: | e(*) | |||
| real(kind=sp), | intent(in) | :: | e2(*) | |||
| integer(kind=ilp), | intent(inout) | :: | nval(*) | |||
| real(kind=sp), | intent(inout) | :: | ab(mmax,*) | |||
| real(kind=sp), | intent(inout) | :: | c(*) | |||
| integer(kind=ilp), | intent(out) | :: | mout | |||
| integer(kind=ilp), | intent(inout) | :: | nab(mmax,*) | |||
| real(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | iwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
DLAEBZ contains the iteration loops which compute and use the function N(w), which is the count of eigenvalues of a symmetric tridiagonal matrix T less than or equal to its argument w. It performs a choice of two types of loops: IJOB=1, followed by IJOB=2: It takes as input a list of intervals and returns a list of sufficiently small intervals whose union contains the same eigenvalues as the union of the original intervals. The input intervals are (AB(j,1),AB(j,2)], j=1,...,MINP. The output interval (AB(j,1),AB(j,2)] will contain eigenvalues NAB(j,1)+1,...,NAB(j,2), where 1 <= j <= MOUT. IJOB=3: It performs a binary search in each input interval (AB(j,1),AB(j,2)] for a point w(j) such that N(w(j))=NVAL(j), and uses C(j) as the starting point of the search. If such a w(j) is found, then on output AB(j,1)=AB(j,2)=w. If no such w(j) is found, then on output (AB(j,1),AB(j,2)] will be a small interval containing the point where N(w) jumps through NVAL(j), unless that point lies outside the initial interval. Note that the intervals are in all cases half-open intervals, i.e., of the form (a,b] , which includes b but not a . To avoid underflow, the matrix should be scaled so that its largest element is no greater than overflow(1/2) * underflow(1/4) in absolute value. To assure the most accurate computation of small eigenvalues, the matrix should be scaled to be not much smaller than that, either. See W. Kahan "Accurate Eigenvalues of a Symmetric Tridiagonal Matrix", Report CS41, Computer Science Dept., Stanford University, July 21, 1966 Note: the arguments are, in general, not checked for unreasonable values.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | ijob | |||
| integer(kind=ilp), | intent(in) | :: | nitmax | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | mmax | |||
| integer(kind=ilp), | intent(in) | :: | minp | |||
| integer(kind=ilp), | intent(in) | :: | nbmin | |||
| real(kind=dp), | intent(in) | :: | abstol | |||
| real(kind=dp), | intent(in) | :: | reltol | |||
| real(kind=dp), | intent(in) | :: | pivmin | |||
| real(kind=dp), | intent(in) | :: | d(*) | |||
| real(kind=dp), | intent(in) | :: | e(*) | |||
| real(kind=dp), | intent(in) | :: | e2(*) | |||
| integer(kind=ilp), | intent(inout) | :: | nval(*) | |||
| real(kind=dp), | intent(inout) | :: | ab(mmax,*) | |||
| real(kind=dp), | intent(inout) | :: | c(*) | |||
| integer(kind=ilp), | intent(out) | :: | mout | |||
| integer(kind=ilp), | intent(inout) | :: | nab(mmax,*) | |||
| real(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | iwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
SLAEBZ contains the iteration loops which compute and use the function N(w), which is the count of eigenvalues of a symmetric tridiagonal matrix T less than or equal to its argument w. It performs a choice of two types of loops: IJOB=1, followed by IJOB=2: It takes as input a list of intervals and returns a list of sufficiently small intervals whose union contains the same eigenvalues as the union of the original intervals. The input intervals are (AB(j,1),AB(j,2)], j=1,...,MINP. The output interval (AB(j,1),AB(j,2)] will contain eigenvalues NAB(j,1)+1,...,NAB(j,2), where 1 <= j <= MOUT. IJOB=3: It performs a binary search in each input interval (AB(j,1),AB(j,2)] for a point w(j) such that N(w(j))=NVAL(j), and uses C(j) as the starting point of the search. If such a w(j) is found, then on output AB(j,1)=AB(j,2)=w. If no such w(j) is found, then on output (AB(j,1),AB(j,2)] will be a small interval containing the point where N(w) jumps through NVAL(j), unless that point lies outside the initial interval. Note that the intervals are in all cases half-open intervals, i.e., of the form (a,b] , which includes b but not a . To avoid underflow, the matrix should be scaled so that its largest element is no greater than overflow(1/2) * underflow(1/4) in absolute value. To assure the most accurate computation of small eigenvalues, the matrix should be scaled to be not much smaller than that, either. See W. Kahan "Accurate Eigenvalues of a Symmetric Tridiagonal Matrix", Report CS41, Computer Science Dept., Stanford University, July 21, 1966 Note: the arguments are, in general, not checked for unreasonable values.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | ijob | |||
| integer(kind=ilp), | intent(in) | :: | nitmax | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | mmax | |||
| integer(kind=ilp), | intent(in) | :: | minp | |||
| integer(kind=ilp), | intent(in) | :: | nbmin | |||
| real(kind=sp), | intent(in) | :: | abstol | |||
| real(kind=sp), | intent(in) | :: | reltol | |||
| real(kind=sp), | intent(in) | :: | pivmin | |||
| real(kind=sp), | intent(in) | :: | d(*) | |||
| real(kind=sp), | intent(in) | :: | e(*) | |||
| real(kind=sp), | intent(in) | :: | e2(*) | |||
| integer(kind=ilp), | intent(inout) | :: | nval(*) | |||
| real(kind=sp), | intent(inout) | :: | ab(mmax,*) | |||
| real(kind=sp), | intent(inout) | :: | c(*) | |||
| integer(kind=ilp), | intent(out) | :: | mout | |||
| integer(kind=ilp), | intent(inout) | :: | nab(mmax,*) | |||
| real(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | iwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
Using the divide and conquer method, LAED0: computes all eigenvalues of a symmetric tridiagonal matrix which is one diagonal block of those from reducing a dense or band Hermitian matrix and corresponding eigenvectors of the dense or band matrix.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | qsiz | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=sp), | intent(inout) | :: | d(*) | |||
| real(kind=sp), | intent(inout) | :: | e(*) | |||
| complex(kind=sp), | intent(inout) | :: | q(ldq,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldq | |||
| complex(kind=sp), | intent(out) | :: | qstore(ldqs,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldqs | |||
| real(kind=sp), | intent(out) | :: | rwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | iwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | icompq | |||
| integer(kind=ilp), | intent(in) | :: | qsiz | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=dp), | intent(inout) | :: | d(*) | |||
| real(kind=dp), | intent(inout) | :: | e(*) | |||
| real(kind=dp), | intent(inout) | :: | q(ldq,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldq | |||
| real(kind=dp), | intent(out) | :: | qstore(ldqs,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldqs | |||
| real(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | iwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | icompq | |||
| integer(kind=ilp), | intent(in) | :: | qsiz | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=sp), | intent(inout) | :: | d(*) | |||
| real(kind=sp), | intent(inout) | :: | e(*) | |||
| real(kind=sp), | intent(inout) | :: | q(ldq,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldq | |||
| real(kind=sp), | intent(out) | :: | qstore(ldqs,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldqs | |||
| real(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | iwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | qsiz | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=dp), | intent(inout) | :: | d(*) | |||
| real(kind=dp), | intent(inout) | :: | e(*) | |||
| complex(kind=dp), | intent(inout) | :: | q(ldq,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldq | |||
| complex(kind=dp), | intent(out) | :: | qstore(ldqs,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldqs | |||
| real(kind=dp), | intent(out) | :: | rwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | iwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
Using the divide and conquer method, CLAED0: computes all eigenvalues of a symmetric tridiagonal matrix which is one diagonal block of those from reducing a dense or band Hermitian matrix and corresponding eigenvectors of the dense or band matrix.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | qsiz | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=sp), | intent(inout) | :: | d(*) | |||
| real(kind=sp), | intent(inout) | :: | e(*) | |||
| complex(kind=sp), | intent(inout) | :: | q(ldq,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldq | |||
| complex(kind=sp), | intent(out) | :: | qstore(ldqs,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldqs | |||
| real(kind=sp), | intent(out) | :: | rwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | iwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
DLAED0 computes all eigenvalues and corresponding eigenvectors of a symmetric tridiagonal matrix using the divide and conquer method.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | icompq | |||
| integer(kind=ilp), | intent(in) | :: | qsiz | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=dp), | intent(inout) | :: | d(*) | |||
| real(kind=dp), | intent(inout) | :: | e(*) | |||
| real(kind=dp), | intent(inout) | :: | q(ldq,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldq | |||
| real(kind=dp), | intent(out) | :: | qstore(ldqs,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldqs | |||
| real(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | iwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
SLAED0 computes all eigenvalues and corresponding eigenvectors of a symmetric tridiagonal matrix using the divide and conquer method.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | icompq | |||
| integer(kind=ilp), | intent(in) | :: | qsiz | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=sp), | intent(inout) | :: | d(*) | |||
| real(kind=sp), | intent(inout) | :: | e(*) | |||
| real(kind=sp), | intent(inout) | :: | q(ldq,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldq | |||
| real(kind=sp), | intent(out) | :: | qstore(ldqs,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldqs | |||
| real(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | iwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
Using the divide and conquer method, ZLAED0: computes all eigenvalues of a symmetric tridiagonal matrix which is one diagonal block of those from reducing a dense or band Hermitian matrix and corresponding eigenvectors of the dense or band matrix.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | qsiz | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=dp), | intent(inout) | :: | d(*) | |||
| real(kind=dp), | intent(inout) | :: | e(*) | |||
| complex(kind=dp), | intent(inout) | :: | q(ldq,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldq | |||
| complex(kind=dp), | intent(out) | :: | qstore(ldqs,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldqs | |||
| real(kind=dp), | intent(out) | :: | rwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | iwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
LAED1 computes the updated eigensystem of a diagonal matrix after modification by a rank-one symmetric matrix. This routine is used only for the eigenproblem which requires all eigenvalues and eigenvectors of a tridiagonal matrix. DLAED7 handles the case in which eigenvalues only or eigenvalues and eigenvectors of a full symmetric matrix (which was reduced to tridiagonal form) are desired. T = Q(in) ( D(in) + RHO * ZZT ) QT(in) = Q(out) * D(out) * QT(out) where Z = QTu, u is a vector of length N with ones in the CUTPNT and CUTPNT + 1 th elements and zeros elsewhere. The eigenvectors of the original matrix are stored in Q, and the eigenvalues are in D. The algorithm consists of three stages: The first stage consists of deflating the size of the problem when there are multiple eigenvalues or if there is a zero in the Z vector. For each such occurrence the dimension of the secular equation problem is reduced by one. This stage is performed by the routine DLAED2. The second stage consists of calculating the updated eigenvalues. This is done by finding the roots of the secular equation via the routine DLAED4 (as called by DLAED3). This routine also calculates the eigenvectors of the current problem. The final stage consists of computing the updated eigenvectors directly using the updated eigenvalues. The eigenvectors for the current problem are multiplied with the eigenvectors from the overall problem.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=dp), | intent(inout) | :: | d(*) | |||
| real(kind=dp), | intent(inout) | :: | q(ldq,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldq | |||
| integer(kind=ilp), | intent(inout) | :: | indxq(*) | |||
| real(kind=dp), | intent(inout) | :: | rho | |||
| integer(kind=ilp), | intent(in) | :: | cutpnt | |||
| real(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | iwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=sp), | intent(inout) | :: | d(*) | |||
| real(kind=sp), | intent(inout) | :: | q(ldq,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldq | |||
| integer(kind=ilp), | intent(inout) | :: | indxq(*) | |||
| real(kind=sp), | intent(inout) | :: | rho | |||
| integer(kind=ilp), | intent(in) | :: | cutpnt | |||
| real(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | iwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
DLAED1 computes the updated eigensystem of a diagonal matrix after modification by a rank-one symmetric matrix. This routine is used only for the eigenproblem which requires all eigenvalues and eigenvectors of a tridiagonal matrix. DLAED7 handles the case in which eigenvalues only or eigenvalues and eigenvectors of a full symmetric matrix (which was reduced to tridiagonal form) are desired. T = Q(in) ( D(in) + RHO * ZZT ) QT(in) = Q(out) * D(out) * QT(out) where Z = QTu, u is a vector of length N with ones in the CUTPNT and CUTPNT + 1 th elements and zeros elsewhere. The eigenvectors of the original matrix are stored in Q, and the eigenvalues are in D. The algorithm consists of three stages: The first stage consists of deflating the size of the problem when there are multiple eigenvalues or if there is a zero in the Z vector. For each such occurrence the dimension of the secular equation problem is reduced by one. This stage is performed by the routine DLAED2. The second stage consists of calculating the updated eigenvalues. This is done by finding the roots of the secular equation via the routine DLAED4 (as called by DLAED3). This routine also calculates the eigenvectors of the current problem. The final stage consists of computing the updated eigenvectors directly using the updated eigenvalues. The eigenvectors for the current problem are multiplied with the eigenvectors from the overall problem.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=dp), | intent(inout) | :: | d(*) | |||
| real(kind=dp), | intent(inout) | :: | q(ldq,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldq | |||
| integer(kind=ilp), | intent(inout) | :: | indxq(*) | |||
| real(kind=dp), | intent(inout) | :: | rho | |||
| integer(kind=ilp), | intent(in) | :: | cutpnt | |||
| real(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | iwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
SLAED1 computes the updated eigensystem of a diagonal matrix after modification by a rank-one symmetric matrix. This routine is used only for the eigenproblem which requires all eigenvalues and eigenvectors of a tridiagonal matrix. SLAED7 handles the case in which eigenvalues only or eigenvalues and eigenvectors of a full symmetric matrix (which was reduced to tridiagonal form) are desired. T = Q(in) ( D(in) + RHO * ZZT ) QT(in) = Q(out) * D(out) * QT(out) where Z = QTu, u is a vector of length N with ones in the CUTPNT and CUTPNT + 1 th elements and zeros elsewhere. The eigenvectors of the original matrix are stored in Q, and the eigenvalues are in D. The algorithm consists of three stages: The first stage consists of deflating the size of the problem when there are multiple eigenvalues or if there is a zero in the Z vector. For each such occurrence the dimension of the secular equation problem is reduced by one. This stage is performed by the routine SLAED2. The second stage consists of calculating the updated eigenvalues. This is done by finding the roots of the secular equation via the routine SLAED4 (as called by SLAED3). This routine also calculates the eigenvectors of the current problem. The final stage consists of computing the updated eigenvectors directly using the updated eigenvalues. The eigenvectors for the current problem are multiplied with the eigenvectors from the overall problem.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=sp), | intent(inout) | :: | d(*) | |||
| real(kind=sp), | intent(inout) | :: | q(ldq,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldq | |||
| integer(kind=ilp), | intent(inout) | :: | indxq(*) | |||
| real(kind=sp), | intent(inout) | :: | rho | |||
| integer(kind=ilp), | intent(in) | :: | cutpnt | |||
| real(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | iwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
This subroutine computes the I-th updated eigenvalue of a symmetric rank-one modification to a diagonal matrix whose elements are given in the array d, and that D(i) < D(j) for i < j and that RHO > 0. This is arranged by the calling routine, and is no loss in generality. The rank-one modified system is thus diag( D ) + RHO * Z * Z_transpose. where we assume the Euclidean norm of Z is 1. The method consists of approximating the rational functions in the secular equation by simpler interpolating rational functions.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | i | |||
| real(kind=dp), | intent(in) | :: | d(*) | |||
| real(kind=dp), | intent(in) | :: | z(*) | |||
| real(kind=dp), | intent(out) | :: | delta(*) | |||
| real(kind=dp), | intent(in) | :: | rho | |||
| real(kind=dp), | intent(out) | :: | dlam | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | i | |||
| real(kind=sp), | intent(in) | :: | d(*) | |||
| real(kind=sp), | intent(in) | :: | z(*) | |||
| real(kind=sp), | intent(out) | :: | delta(*) | |||
| real(kind=sp), | intent(in) | :: | rho | |||
| real(kind=sp), | intent(out) | :: | dlam | |||
| integer(kind=ilp), | intent(out) | :: | info |
This subroutine computes the I-th updated eigenvalue of a symmetric rank-one modification to a diagonal matrix whose elements are given in the array d, and that D(i) < D(j) for i < j and that RHO > 0. This is arranged by the calling routine, and is no loss in generality. The rank-one modified system is thus diag( D ) + RHO * Z * Z_transpose. where we assume the Euclidean norm of Z is 1. The method consists of approximating the rational functions in the secular equation by simpler interpolating rational functions.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | i | |||
| real(kind=dp), | intent(in) | :: | d(*) | |||
| real(kind=dp), | intent(in) | :: | z(*) | |||
| real(kind=dp), | intent(out) | :: | delta(*) | |||
| real(kind=dp), | intent(in) | :: | rho | |||
| real(kind=dp), | intent(out) | :: | dlam | |||
| integer(kind=ilp), | intent(out) | :: | info |
This subroutine computes the I-th updated eigenvalue of a symmetric rank-one modification to a diagonal matrix whose elements are given in the array d, and that D(i) < D(j) for i < j and that RHO > 0. This is arranged by the calling routine, and is no loss in generality. The rank-one modified system is thus diag( D ) + RHO * Z * Z_transpose. where we assume the Euclidean norm of Z is 1. The method consists of approximating the rational functions in the secular equation by simpler interpolating rational functions.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | i | |||
| real(kind=sp), | intent(in) | :: | d(*) | |||
| real(kind=sp), | intent(in) | :: | z(*) | |||
| real(kind=sp), | intent(out) | :: | delta(*) | |||
| real(kind=sp), | intent(in) | :: | rho | |||
| real(kind=sp), | intent(out) | :: | dlam | |||
| integer(kind=ilp), | intent(out) | :: | info |
This subroutine computes the I-th eigenvalue of a symmetric rank-one modification of a 2-by-2 diagonal matrix diag( D ) + RHO * Z * transpose(Z) . The diagonal elements in the array D are assumed to satisfy D(i) < D(j) for i < j . We also assume RHO > 0 and that the Euclidean norm of the vector Z is one.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | i | |||
| real(kind=dp), | intent(in) | :: | d(2) | |||
| real(kind=dp), | intent(in) | :: | z(2) | |||
| real(kind=dp), | intent(out) | :: | delta(2) | |||
| real(kind=dp), | intent(in) | :: | rho | |||
| real(kind=dp), | intent(out) | :: | dlam |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | i | |||
| real(kind=sp), | intent(in) | :: | d(2) | |||
| real(kind=sp), | intent(in) | :: | z(2) | |||
| real(kind=sp), | intent(out) | :: | delta(2) | |||
| real(kind=sp), | intent(in) | :: | rho | |||
| real(kind=sp), | intent(out) | :: | dlam |
This subroutine computes the I-th eigenvalue of a symmetric rank-one modification of a 2-by-2 diagonal matrix diag( D ) + RHO * Z * transpose(Z) . The diagonal elements in the array D are assumed to satisfy D(i) < D(j) for i < j . We also assume RHO > 0 and that the Euclidean norm of the vector Z is one.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | i | |||
| real(kind=dp), | intent(in) | :: | d(2) | |||
| real(kind=dp), | intent(in) | :: | z(2) | |||
| real(kind=dp), | intent(out) | :: | delta(2) | |||
| real(kind=dp), | intent(in) | :: | rho | |||
| real(kind=dp), | intent(out) | :: | dlam |
This subroutine computes the I-th eigenvalue of a symmetric rank-one modification of a 2-by-2 diagonal matrix diag( D ) + RHO * Z * transpose(Z) . The diagonal elements in the array D are assumed to satisfy D(i) < D(j) for i < j . We also assume RHO > 0 and that the Euclidean norm of the vector Z is one.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | i | |||
| real(kind=sp), | intent(in) | :: | d(2) | |||
| real(kind=sp), | intent(in) | :: | z(2) | |||
| real(kind=sp), | intent(out) | :: | delta(2) | |||
| real(kind=sp), | intent(in) | :: | rho | |||
| real(kind=sp), | intent(out) | :: | dlam |
LAED6 computes the positive or negative root (closest to the origin) of z(1) z(2) z(3) f(x) = rho + --------- + ---------- + --------- d(1)-x d(2)-x d(3)-x It is assumed that if ORGATI = .true. the root is between d(2) and d(3); otherwise it is between d(1) and d(2) This routine will be called by DLAED4 when necessary. In most cases, the root sought is the smallest in magnitude, though it might not be in some extremely rare situations.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | kniter | |||
| logical(kind=lk), | intent(in) | :: | orgati | |||
| real(kind=dp), | intent(in) | :: | rho | |||
| real(kind=dp), | intent(in) | :: | d(3) | |||
| real(kind=dp), | intent(in) | :: | z(3) | |||
| real(kind=dp), | intent(in) | :: | finit | |||
| real(kind=dp), | intent(out) | :: | tau | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | kniter | |||
| logical(kind=lk), | intent(in) | :: | orgati | |||
| real(kind=sp), | intent(in) | :: | rho | |||
| real(kind=sp), | intent(in) | :: | d(3) | |||
| real(kind=sp), | intent(in) | :: | z(3) | |||
| real(kind=sp), | intent(in) | :: | finit | |||
| real(kind=sp), | intent(out) | :: | tau | |||
| integer(kind=ilp), | intent(out) | :: | info |
DLAED6 computes the positive or negative root (closest to the origin) of z(1) z(2) z(3) f(x) = rho + --------- + ---------- + --------- d(1)-x d(2)-x d(3)-x It is assumed that if ORGATI = .true. the root is between d(2) and d(3); otherwise it is between d(1) and d(2) This routine will be called by DLAED4 when necessary. In most cases, the root sought is the smallest in magnitude, though it might not be in some extremely rare situations.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | kniter | |||
| logical(kind=lk), | intent(in) | :: | orgati | |||
| real(kind=dp), | intent(in) | :: | rho | |||
| real(kind=dp), | intent(in) | :: | d(3) | |||
| real(kind=dp), | intent(in) | :: | z(3) | |||
| real(kind=dp), | intent(in) | :: | finit | |||
| real(kind=dp), | intent(out) | :: | tau | |||
| integer(kind=ilp), | intent(out) | :: | info |
SLAED6 computes the positive or negative root (closest to the origin) of z(1) z(2) z(3) f(x) = rho + --------- + ---------- + --------- d(1)-x d(2)-x d(3)-x It is assumed that if ORGATI = .true. the root is between d(2) and d(3); otherwise it is between d(1) and d(2) This routine will be called by SLAED4 when necessary. In most cases, the root sought is the smallest in magnitude, though it might not be in some extremely rare situations.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | kniter | |||
| logical(kind=lk), | intent(in) | :: | orgati | |||
| real(kind=sp), | intent(in) | :: | rho | |||
| real(kind=sp), | intent(in) | :: | d(3) | |||
| real(kind=sp), | intent(in) | :: | z(3) | |||
| real(kind=sp), | intent(in) | :: | finit | |||
| real(kind=sp), | intent(out) | :: | tau | |||
| integer(kind=ilp), | intent(out) | :: | info |
LAED7 computes the updated eigensystem of a diagonal matrix after modification by a rank-one symmetric matrix. This routine is used only for the eigenproblem which requires all eigenvalues and optionally eigenvectors of a dense or banded Hermitian matrix that has been reduced to tridiagonal form. T = Q(in) ( D(in) + RHO * ZZH ) QH(in) = Q(out) * D(out) * QH(out) where Z = Q*Hu, u is a vector of length N with ones in the CUTPNT and CUTPNT + 1 th elements and zeros elsewhere. The eigenvectors of the original matrix are stored in Q, and the eigenvalues are in D. The algorithm consists of three stages: The first stage consists of deflating the size of the problem when there are multiple eigenvalues or if there is a zero in the Z vector. For each such occurrence the dimension of the secular equation problem is reduced by one. This stage is performed by the routine SLAED2. The second stage consists of calculating the updated eigenvalues. This is done by finding the roots of the secular equation via the routine SLAED4 (as called by SLAED3). This routine also calculates the eigenvectors of the current problem. The final stage consists of computing the updated eigenvectors directly using the updated eigenvalues. The eigenvectors for the current problem are multiplied with the eigenvectors from the overall problem.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | cutpnt | |||
| integer(kind=ilp), | intent(in) | :: | qsiz | |||
| integer(kind=ilp), | intent(in) | :: | tlvls | |||
| integer(kind=ilp), | intent(in) | :: | curlvl | |||
| integer(kind=ilp), | intent(in) | :: | curpbm | |||
| real(kind=sp), | intent(inout) | :: | d(*) | |||
| complex(kind=sp), | intent(inout) | :: | q(ldq,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldq | |||
| real(kind=sp), | intent(inout) | :: | rho | |||
| integer(kind=ilp), | intent(out) | :: | indxq(*) | |||
| real(kind=sp), | intent(inout) | :: | qstore(*) | |||
| integer(kind=ilp), | intent(inout) | :: | qptr(*) | |||
| integer(kind=ilp), | intent(inout) | :: | prmptr(*) | |||
| integer(kind=ilp), | intent(inout) | :: | perm(*) | |||
| integer(kind=ilp), | intent(inout) | :: | givptr(*) | |||
| integer(kind=ilp), | intent(inout) | :: | givcol(2,*) | |||
| real(kind=sp), | intent(inout) | :: | givnum(2,*) | |||
| complex(kind=sp), | intent(out) | :: | work(*) | |||
| real(kind=sp), | intent(out) | :: | rwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | iwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | icompq | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | qsiz | |||
| integer(kind=ilp), | intent(in) | :: | tlvls | |||
| integer(kind=ilp), | intent(in) | :: | curlvl | |||
| integer(kind=ilp), | intent(in) | :: | curpbm | |||
| real(kind=dp), | intent(inout) | :: | d(*) | |||
| real(kind=dp), | intent(inout) | :: | q(ldq,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldq | |||
| integer(kind=ilp), | intent(out) | :: | indxq(*) | |||
| real(kind=dp), | intent(inout) | :: | rho | |||
| integer(kind=ilp), | intent(in) | :: | cutpnt | |||
| real(kind=dp), | intent(inout) | :: | qstore(*) | |||
| integer(kind=ilp), | intent(inout) | :: | qptr(*) | |||
| integer(kind=ilp), | intent(inout) | :: | prmptr(*) | |||
| integer(kind=ilp), | intent(inout) | :: | perm(*) | |||
| integer(kind=ilp), | intent(inout) | :: | givptr(*) | |||
| integer(kind=ilp), | intent(inout) | :: | givcol(2,*) | |||
| real(kind=dp), | intent(inout) | :: | givnum(2,*) | |||
| real(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | iwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | icompq | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | qsiz | |||
| integer(kind=ilp), | intent(in) | :: | tlvls | |||
| integer(kind=ilp), | intent(in) | :: | curlvl | |||
| integer(kind=ilp), | intent(in) | :: | curpbm | |||
| real(kind=sp), | intent(inout) | :: | d(*) | |||
| real(kind=sp), | intent(inout) | :: | q(ldq,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldq | |||
| integer(kind=ilp), | intent(out) | :: | indxq(*) | |||
| real(kind=sp), | intent(inout) | :: | rho | |||
| integer(kind=ilp), | intent(in) | :: | cutpnt | |||
| real(kind=sp), | intent(inout) | :: | qstore(*) | |||
| integer(kind=ilp), | intent(inout) | :: | qptr(*) | |||
| integer(kind=ilp), | intent(inout) | :: | prmptr(*) | |||
| integer(kind=ilp), | intent(inout) | :: | perm(*) | |||
| integer(kind=ilp), | intent(inout) | :: | givptr(*) | |||
| integer(kind=ilp), | intent(inout) | :: | givcol(2,*) | |||
| real(kind=sp), | intent(inout) | :: | givnum(2,*) | |||
| real(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | iwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | cutpnt | |||
| integer(kind=ilp), | intent(in) | :: | qsiz | |||
| integer(kind=ilp), | intent(in) | :: | tlvls | |||
| integer(kind=ilp), | intent(in) | :: | curlvl | |||
| integer(kind=ilp), | intent(in) | :: | curpbm | |||
| real(kind=dp), | intent(inout) | :: | d(*) | |||
| complex(kind=dp), | intent(inout) | :: | q(ldq,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldq | |||
| real(kind=dp), | intent(inout) | :: | rho | |||
| integer(kind=ilp), | intent(out) | :: | indxq(*) | |||
| real(kind=dp), | intent(inout) | :: | qstore(*) | |||
| integer(kind=ilp), | intent(inout) | :: | qptr(*) | |||
| integer(kind=ilp), | intent(inout) | :: | prmptr(*) | |||
| integer(kind=ilp), | intent(inout) | :: | perm(*) | |||
| integer(kind=ilp), | intent(inout) | :: | givptr(*) | |||
| integer(kind=ilp), | intent(inout) | :: | givcol(2,*) | |||
| real(kind=dp), | intent(inout) | :: | givnum(2,*) | |||
| complex(kind=dp), | intent(out) | :: | work(*) | |||
| real(kind=dp), | intent(out) | :: | rwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | iwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
CLAED7 computes the updated eigensystem of a diagonal matrix after modification by a rank-one symmetric matrix. This routine is used only for the eigenproblem which requires all eigenvalues and optionally eigenvectors of a dense or banded Hermitian matrix that has been reduced to tridiagonal form. T = Q(in) ( D(in) + RHO * ZZH ) QH(in) = Q(out) * D(out) * QH(out) where Z = Q*Hu, u is a vector of length N with ones in the CUTPNT and CUTPNT + 1 th elements and zeros elsewhere. The eigenvectors of the original matrix are stored in Q, and the eigenvalues are in D. The algorithm consists of three stages: The first stage consists of deflating the size of the problem when there are multiple eigenvalues or if there is a zero in the Z vector. For each such occurrence the dimension of the secular equation problem is reduced by one. This stage is performed by the routine SLAED2. The second stage consists of calculating the updated eigenvalues. This is done by finding the roots of the secular equation via the routine SLAED4 (as called by SLAED3). This routine also calculates the eigenvectors of the current problem. The final stage consists of computing the updated eigenvectors directly using the updated eigenvalues. The eigenvectors for the current problem are multiplied with the eigenvectors from the overall problem.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | cutpnt | |||
| integer(kind=ilp), | intent(in) | :: | qsiz | |||
| integer(kind=ilp), | intent(in) | :: | tlvls | |||
| integer(kind=ilp), | intent(in) | :: | curlvl | |||
| integer(kind=ilp), | intent(in) | :: | curpbm | |||
| real(kind=sp), | intent(inout) | :: | d(*) | |||
| complex(kind=sp), | intent(inout) | :: | q(ldq,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldq | |||
| real(kind=sp), | intent(inout) | :: | rho | |||
| integer(kind=ilp), | intent(out) | :: | indxq(*) | |||
| real(kind=sp), | intent(inout) | :: | qstore(*) | |||
| integer(kind=ilp), | intent(inout) | :: | qptr(*) | |||
| integer(kind=ilp), | intent(inout) | :: | prmptr(*) | |||
| integer(kind=ilp), | intent(inout) | :: | perm(*) | |||
| integer(kind=ilp), | intent(inout) | :: | givptr(*) | |||
| integer(kind=ilp), | intent(inout) | :: | givcol(2,*) | |||
| real(kind=sp), | intent(inout) | :: | givnum(2,*) | |||
| complex(kind=sp), | intent(out) | :: | work(*) | |||
| real(kind=sp), | intent(out) | :: | rwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | iwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
DLAED7 computes the updated eigensystem of a diagonal matrix after modification by a rank-one symmetric matrix. This routine is used only for the eigenproblem which requires all eigenvalues and optionally eigenvectors of a dense symmetric matrix that has been reduced to tridiagonal form. DLAED1 handles the case in which all eigenvalues and eigenvectors of a symmetric tridiagonal matrix are desired. T = Q(in) ( D(in) + RHO * ZZT ) QT(in) = Q(out) * D(out) * QT(out) where Z = Q*Tu, u is a vector of length N with ones in the CUTPNT and CUTPNT + 1 th elements and zeros elsewhere. The eigenvectors of the original matrix are stored in Q, and the eigenvalues are in D. The algorithm consists of three stages: The first stage consists of deflating the size of the problem when there are multiple eigenvalues or if there is a zero in the Z vector. For each such occurrence the dimension of the secular equation problem is reduced by one. This stage is performed by the routine DLAED8. The second stage consists of calculating the updated eigenvalues. This is done by finding the roots of the secular equation via the routine DLAED4 (as called by DLAED9). This routine also calculates the eigenvectors of the current problem. The final stage consists of computing the updated eigenvectors directly using the updated eigenvalues. The eigenvectors for the current problem are multiplied with the eigenvectors from the overall problem.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | icompq | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | qsiz | |||
| integer(kind=ilp), | intent(in) | :: | tlvls | |||
| integer(kind=ilp), | intent(in) | :: | curlvl | |||
| integer(kind=ilp), | intent(in) | :: | curpbm | |||
| real(kind=dp), | intent(inout) | :: | d(*) | |||
| real(kind=dp), | intent(inout) | :: | q(ldq,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldq | |||
| integer(kind=ilp), | intent(out) | :: | indxq(*) | |||
| real(kind=dp), | intent(inout) | :: | rho | |||
| integer(kind=ilp), | intent(in) | :: | cutpnt | |||
| real(kind=dp), | intent(inout) | :: | qstore(*) | |||
| integer(kind=ilp), | intent(inout) | :: | qptr(*) | |||
| integer(kind=ilp), | intent(inout) | :: | prmptr(*) | |||
| integer(kind=ilp), | intent(inout) | :: | perm(*) | |||
| integer(kind=ilp), | intent(inout) | :: | givptr(*) | |||
| integer(kind=ilp), | intent(inout) | :: | givcol(2,*) | |||
| real(kind=dp), | intent(inout) | :: | givnum(2,*) | |||
| real(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | iwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
SLAED7 computes the updated eigensystem of a diagonal matrix after modification by a rank-one symmetric matrix. This routine is used only for the eigenproblem which requires all eigenvalues and optionally eigenvectors of a dense symmetric matrix that has been reduced to tridiagonal form. SLAED1 handles the case in which all eigenvalues and eigenvectors of a symmetric tridiagonal matrix are desired. T = Q(in) ( D(in) + RHO * ZZT ) QT(in) = Q(out) * D(out) * QT(out) where Z = Q*Tu, u is a vector of length N with ones in the CUTPNT and CUTPNT + 1 th elements and zeros elsewhere. The eigenvectors of the original matrix are stored in Q, and the eigenvalues are in D. The algorithm consists of three stages: The first stage consists of deflating the size of the problem when there are multiple eigenvalues or if there is a zero in the Z vector. For each such occurrence the dimension of the secular equation problem is reduced by one. This stage is performed by the routine SLAED8. The second stage consists of calculating the updated eigenvalues. This is done by finding the roots of the secular equation via the routine SLAED4 (as called by SLAED9). This routine also calculates the eigenvectors of the current problem. The final stage consists of computing the updated eigenvectors directly using the updated eigenvalues. The eigenvectors for the current problem are multiplied with the eigenvectors from the overall problem.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | icompq | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | qsiz | |||
| integer(kind=ilp), | intent(in) | :: | tlvls | |||
| integer(kind=ilp), | intent(in) | :: | curlvl | |||
| integer(kind=ilp), | intent(in) | :: | curpbm | |||
| real(kind=sp), | intent(inout) | :: | d(*) | |||
| real(kind=sp), | intent(inout) | :: | q(ldq,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldq | |||
| integer(kind=ilp), | intent(out) | :: | indxq(*) | |||
| real(kind=sp), | intent(inout) | :: | rho | |||
| integer(kind=ilp), | intent(in) | :: | cutpnt | |||
| real(kind=sp), | intent(inout) | :: | qstore(*) | |||
| integer(kind=ilp), | intent(inout) | :: | qptr(*) | |||
| integer(kind=ilp), | intent(inout) | :: | prmptr(*) | |||
| integer(kind=ilp), | intent(inout) | :: | perm(*) | |||
| integer(kind=ilp), | intent(inout) | :: | givptr(*) | |||
| integer(kind=ilp), | intent(inout) | :: | givcol(2,*) | |||
| real(kind=sp), | intent(inout) | :: | givnum(2,*) | |||
| real(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | iwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
ZLAED7 computes the updated eigensystem of a diagonal matrix after modification by a rank-one symmetric matrix. This routine is used only for the eigenproblem which requires all eigenvalues and optionally eigenvectors of a dense or banded Hermitian matrix that has been reduced to tridiagonal form. T = Q(in) ( D(in) + RHO * ZZH ) QH(in) = Q(out) * D(out) * QH(out) where Z = Q*Hu, u is a vector of length N with ones in the CUTPNT and CUTPNT + 1 th elements and zeros elsewhere. The eigenvectors of the original matrix are stored in Q, and the eigenvalues are in D. The algorithm consists of three stages: The first stage consists of deflating the size of the problem when there are multiple eigenvalues or if there is a zero in the Z vector. For each such occurrence the dimension of the secular equation problem is reduced by one. This stage is performed by the routine DLAED2. The second stage consists of calculating the updated eigenvalues. This is done by finding the roots of the secular equation via the routine DLAED4 (as called by SLAED3). This routine also calculates the eigenvectors of the current problem. The final stage consists of computing the updated eigenvectors directly using the updated eigenvalues. The eigenvectors for the current problem are multiplied with the eigenvectors from the overall problem.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | cutpnt | |||
| integer(kind=ilp), | intent(in) | :: | qsiz | |||
| integer(kind=ilp), | intent(in) | :: | tlvls | |||
| integer(kind=ilp), | intent(in) | :: | curlvl | |||
| integer(kind=ilp), | intent(in) | :: | curpbm | |||
| real(kind=dp), | intent(inout) | :: | d(*) | |||
| complex(kind=dp), | intent(inout) | :: | q(ldq,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldq | |||
| real(kind=dp), | intent(inout) | :: | rho | |||
| integer(kind=ilp), | intent(out) | :: | indxq(*) | |||
| real(kind=dp), | intent(inout) | :: | qstore(*) | |||
| integer(kind=ilp), | intent(inout) | :: | qptr(*) | |||
| integer(kind=ilp), | intent(inout) | :: | prmptr(*) | |||
| integer(kind=ilp), | intent(inout) | :: | perm(*) | |||
| integer(kind=ilp), | intent(inout) | :: | givptr(*) | |||
| integer(kind=ilp), | intent(inout) | :: | givcol(2,*) | |||
| real(kind=dp), | intent(inout) | :: | givnum(2,*) | |||
| complex(kind=dp), | intent(out) | :: | work(*) | |||
| real(kind=dp), | intent(out) | :: | rwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | iwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
LAED8 merges the two sets of eigenvalues together into a single sorted set. Then it tries to deflate the size of the problem. There are two ways in which deflation can occur: when two or more eigenvalues are close together or if there is a tiny element in the Z vector. For each such occurrence the order of the related secular equation problem is reduced by one.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(out) | :: | k | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | qsiz | |||
| complex(kind=sp), | intent(inout) | :: | q(ldq,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldq | |||
| real(kind=sp), | intent(inout) | :: | d(*) | |||
| real(kind=sp), | intent(inout) | :: | rho | |||
| integer(kind=ilp), | intent(in) | :: | cutpnt | |||
| real(kind=sp), | intent(inout) | :: | z(*) | |||
| real(kind=sp), | intent(out) | :: | dlamda(*) | |||
| complex(kind=sp), | intent(out) | :: | q2(ldq2,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldq2 | |||
| real(kind=sp), | intent(out) | :: | w(*) | |||
| integer(kind=ilp), | intent(out) | :: | indxp(*) | |||
| integer(kind=ilp), | intent(out) | :: | indx(*) | |||
| integer(kind=ilp), | intent(inout) | :: | indxq(*) | |||
| integer(kind=ilp), | intent(out) | :: | perm(*) | |||
| integer(kind=ilp), | intent(out) | :: | givptr | |||
| integer(kind=ilp), | intent(out) | :: | givcol(2,*) | |||
| real(kind=sp), | intent(out) | :: | givnum(2,*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | icompq | |||
| integer(kind=ilp), | intent(out) | :: | k | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | qsiz | |||
| real(kind=dp), | intent(inout) | :: | d(*) | |||
| real(kind=dp), | intent(inout) | :: | q(ldq,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldq | |||
| integer(kind=ilp), | intent(inout) | :: | indxq(*) | |||
| real(kind=dp), | intent(inout) | :: | rho | |||
| integer(kind=ilp), | intent(in) | :: | cutpnt | |||
| real(kind=dp), | intent(inout) | :: | z(*) | |||
| real(kind=dp), | intent(out) | :: | dlamda(*) | |||
| real(kind=dp), | intent(out) | :: | q2(ldq2,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldq2 | |||
| real(kind=dp), | intent(out) | :: | w(*) | |||
| integer(kind=ilp), | intent(out) | :: | perm(*) | |||
| integer(kind=ilp), | intent(out) | :: | givptr | |||
| integer(kind=ilp), | intent(out) | :: | givcol(2,*) | |||
| real(kind=dp), | intent(out) | :: | givnum(2,*) | |||
| integer(kind=ilp), | intent(out) | :: | indxp(*) | |||
| integer(kind=ilp), | intent(out) | :: | indx(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | icompq | |||
| integer(kind=ilp), | intent(out) | :: | k | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | qsiz | |||
| real(kind=sp), | intent(inout) | :: | d(*) | |||
| real(kind=sp), | intent(inout) | :: | q(ldq,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldq | |||
| integer(kind=ilp), | intent(inout) | :: | indxq(*) | |||
| real(kind=sp), | intent(inout) | :: | rho | |||
| integer(kind=ilp), | intent(in) | :: | cutpnt | |||
| real(kind=sp), | intent(inout) | :: | z(*) | |||
| real(kind=sp), | intent(out) | :: | dlamda(*) | |||
| real(kind=sp), | intent(out) | :: | q2(ldq2,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldq2 | |||
| real(kind=sp), | intent(out) | :: | w(*) | |||
| integer(kind=ilp), | intent(out) | :: | perm(*) | |||
| integer(kind=ilp), | intent(out) | :: | givptr | |||
| integer(kind=ilp), | intent(out) | :: | givcol(2,*) | |||
| real(kind=sp), | intent(out) | :: | givnum(2,*) | |||
| integer(kind=ilp), | intent(out) | :: | indxp(*) | |||
| integer(kind=ilp), | intent(out) | :: | indx(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(out) | :: | k | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | qsiz | |||
| complex(kind=dp), | intent(inout) | :: | q(ldq,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldq | |||
| real(kind=dp), | intent(inout) | :: | d(*) | |||
| real(kind=dp), | intent(inout) | :: | rho | |||
| integer(kind=ilp), | intent(in) | :: | cutpnt | |||
| real(kind=dp), | intent(inout) | :: | z(*) | |||
| real(kind=dp), | intent(out) | :: | dlamda(*) | |||
| complex(kind=dp), | intent(out) | :: | q2(ldq2,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldq2 | |||
| real(kind=dp), | intent(out) | :: | w(*) | |||
| integer(kind=ilp), | intent(out) | :: | indxp(*) | |||
| integer(kind=ilp), | intent(out) | :: | indx(*) | |||
| integer(kind=ilp), | intent(inout) | :: | indxq(*) | |||
| integer(kind=ilp), | intent(out) | :: | perm(*) | |||
| integer(kind=ilp), | intent(out) | :: | givptr | |||
| integer(kind=ilp), | intent(out) | :: | givcol(2,*) | |||
| real(kind=dp), | intent(out) | :: | givnum(2,*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
CLAED8 merges the two sets of eigenvalues together into a single sorted set. Then it tries to deflate the size of the problem. There are two ways in which deflation can occur: when two or more eigenvalues are close together or if there is a tiny element in the Z vector. For each such occurrence the order of the related secular equation problem is reduced by one.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(out) | :: | k | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | qsiz | |||
| complex(kind=sp), | intent(inout) | :: | q(ldq,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldq | |||
| real(kind=sp), | intent(inout) | :: | d(*) | |||
| real(kind=sp), | intent(inout) | :: | rho | |||
| integer(kind=ilp), | intent(in) | :: | cutpnt | |||
| real(kind=sp), | intent(inout) | :: | z(*) | |||
| real(kind=sp), | intent(out) | :: | dlamda(*) | |||
| complex(kind=sp), | intent(out) | :: | q2(ldq2,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldq2 | |||
| real(kind=sp), | intent(out) | :: | w(*) | |||
| integer(kind=ilp), | intent(out) | :: | indxp(*) | |||
| integer(kind=ilp), | intent(out) | :: | indx(*) | |||
| integer(kind=ilp), | intent(inout) | :: | indxq(*) | |||
| integer(kind=ilp), | intent(out) | :: | perm(*) | |||
| integer(kind=ilp), | intent(out) | :: | givptr | |||
| integer(kind=ilp), | intent(out) | :: | givcol(2,*) | |||
| real(kind=sp), | intent(out) | :: | givnum(2,*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
DLAED8 merges the two sets of eigenvalues together into a single sorted set. Then it tries to deflate the size of the problem. There are two ways in which deflation can occur: when two or more eigenvalues are close together or if there is a tiny element in the Z vector. For each such occurrence the order of the related secular equation problem is reduced by one.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | icompq | |||
| integer(kind=ilp), | intent(out) | :: | k | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | qsiz | |||
| real(kind=dp), | intent(inout) | :: | d(*) | |||
| real(kind=dp), | intent(inout) | :: | q(ldq,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldq | |||
| integer(kind=ilp), | intent(inout) | :: | indxq(*) | |||
| real(kind=dp), | intent(inout) | :: | rho | |||
| integer(kind=ilp), | intent(in) | :: | cutpnt | |||
| real(kind=dp), | intent(inout) | :: | z(*) | |||
| real(kind=dp), | intent(out) | :: | dlamda(*) | |||
| real(kind=dp), | intent(out) | :: | q2(ldq2,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldq2 | |||
| real(kind=dp), | intent(out) | :: | w(*) | |||
| integer(kind=ilp), | intent(out) | :: | perm(*) | |||
| integer(kind=ilp), | intent(out) | :: | givptr | |||
| integer(kind=ilp), | intent(out) | :: | givcol(2,*) | |||
| real(kind=dp), | intent(out) | :: | givnum(2,*) | |||
| integer(kind=ilp), | intent(out) | :: | indxp(*) | |||
| integer(kind=ilp), | intent(out) | :: | indx(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
SLAED8 merges the two sets of eigenvalues together into a single sorted set. Then it tries to deflate the size of the problem. There are two ways in which deflation can occur: when two or more eigenvalues are close together or if there is a tiny element in the Z vector. For each such occurrence the order of the related secular equation problem is reduced by one.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | icompq | |||
| integer(kind=ilp), | intent(out) | :: | k | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | qsiz | |||
| real(kind=sp), | intent(inout) | :: | d(*) | |||
| real(kind=sp), | intent(inout) | :: | q(ldq,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldq | |||
| integer(kind=ilp), | intent(inout) | :: | indxq(*) | |||
| real(kind=sp), | intent(inout) | :: | rho | |||
| integer(kind=ilp), | intent(in) | :: | cutpnt | |||
| real(kind=sp), | intent(inout) | :: | z(*) | |||
| real(kind=sp), | intent(out) | :: | dlamda(*) | |||
| real(kind=sp), | intent(out) | :: | q2(ldq2,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldq2 | |||
| real(kind=sp), | intent(out) | :: | w(*) | |||
| integer(kind=ilp), | intent(out) | :: | perm(*) | |||
| integer(kind=ilp), | intent(out) | :: | givptr | |||
| integer(kind=ilp), | intent(out) | :: | givcol(2,*) | |||
| real(kind=sp), | intent(out) | :: | givnum(2,*) | |||
| integer(kind=ilp), | intent(out) | :: | indxp(*) | |||
| integer(kind=ilp), | intent(out) | :: | indx(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
ZLAED8 merges the two sets of eigenvalues together into a single sorted set. Then it tries to deflate the size of the problem. There are two ways in which deflation can occur: when two or more eigenvalues are close together or if there is a tiny element in the Z vector. For each such occurrence the order of the related secular equation problem is reduced by one.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(out) | :: | k | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | qsiz | |||
| complex(kind=dp), | intent(inout) | :: | q(ldq,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldq | |||
| real(kind=dp), | intent(inout) | :: | d(*) | |||
| real(kind=dp), | intent(inout) | :: | rho | |||
| integer(kind=ilp), | intent(in) | :: | cutpnt | |||
| real(kind=dp), | intent(inout) | :: | z(*) | |||
| real(kind=dp), | intent(out) | :: | dlamda(*) | |||
| complex(kind=dp), | intent(out) | :: | q2(ldq2,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldq2 | |||
| real(kind=dp), | intent(out) | :: | w(*) | |||
| integer(kind=ilp), | intent(out) | :: | indxp(*) | |||
| integer(kind=ilp), | intent(out) | :: | indx(*) | |||
| integer(kind=ilp), | intent(inout) | :: | indxq(*) | |||
| integer(kind=ilp), | intent(out) | :: | perm(*) | |||
| integer(kind=ilp), | intent(out) | :: | givptr | |||
| integer(kind=ilp), | intent(out) | :: | givcol(2,*) | |||
| real(kind=dp), | intent(out) | :: | givnum(2,*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
LAED9 finds the roots of the secular equation, as defined by the values in D, Z, and RHO, between KSTART and KSTOP. It makes the appropriate calls to DLAED4 and then stores the new matrix of eigenvectors for use in calculating the next level of Z vectors.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | k | |||
| integer(kind=ilp), | intent(in) | :: | kstart | |||
| integer(kind=ilp), | intent(in) | :: | kstop | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=dp), | intent(out) | :: | d(*) | |||
| real(kind=dp), | intent(out) | :: | q(ldq,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldq | |||
| real(kind=dp), | intent(in) | :: | rho | |||
| real(kind=dp), | intent(inout) | :: | dlamda(*) | |||
| real(kind=dp), | intent(inout) | :: | w(*) | |||
| real(kind=dp), | intent(out) | :: | s(lds,*) | |||
| integer(kind=ilp), | intent(in) | :: | lds | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | k | |||
| integer(kind=ilp), | intent(in) | :: | kstart | |||
| integer(kind=ilp), | intent(in) | :: | kstop | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=sp), | intent(out) | :: | d(*) | |||
| real(kind=sp), | intent(out) | :: | q(ldq,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldq | |||
| real(kind=sp), | intent(in) | :: | rho | |||
| real(kind=sp), | intent(inout) | :: | dlamda(*) | |||
| real(kind=sp), | intent(inout) | :: | w(*) | |||
| real(kind=sp), | intent(out) | :: | s(lds,*) | |||
| integer(kind=ilp), | intent(in) | :: | lds | |||
| integer(kind=ilp), | intent(out) | :: | info |
DLAED9 finds the roots of the secular equation, as defined by the values in D, Z, and RHO, between KSTART and KSTOP. It makes the appropriate calls to DLAED4 and then stores the new matrix of eigenvectors for use in calculating the next level of Z vectors.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | k | |||
| integer(kind=ilp), | intent(in) | :: | kstart | |||
| integer(kind=ilp), | intent(in) | :: | kstop | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=dp), | intent(out) | :: | d(*) | |||
| real(kind=dp), | intent(out) | :: | q(ldq,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldq | |||
| real(kind=dp), | intent(in) | :: | rho | |||
| real(kind=dp), | intent(inout) | :: | dlamda(*) | |||
| real(kind=dp), | intent(inout) | :: | w(*) | |||
| real(kind=dp), | intent(out) | :: | s(lds,*) | |||
| integer(kind=ilp), | intent(in) | :: | lds | |||
| integer(kind=ilp), | intent(out) | :: | info |
SLAED9 finds the roots of the secular equation, as defined by the values in D, Z, and RHO, between KSTART and KSTOP. It makes the appropriate calls to SLAED4 and then stores the new matrix of eigenvectors for use in calculating the next level of Z vectors.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | k | |||
| integer(kind=ilp), | intent(in) | :: | kstart | |||
| integer(kind=ilp), | intent(in) | :: | kstop | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=sp), | intent(out) | :: | d(*) | |||
| real(kind=sp), | intent(out) | :: | q(ldq,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldq | |||
| real(kind=sp), | intent(in) | :: | rho | |||
| real(kind=sp), | intent(inout) | :: | dlamda(*) | |||
| real(kind=sp), | intent(inout) | :: | w(*) | |||
| real(kind=sp), | intent(out) | :: | s(lds,*) | |||
| integer(kind=ilp), | intent(in) | :: | lds | |||
| integer(kind=ilp), | intent(out) | :: | info |
LAEDA computes the Z vector corresponding to the merge step in the CURLVLth step of the merge process with TLVLS steps for the CURPBMth problem.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | tlvls | |||
| integer(kind=ilp), | intent(in) | :: | curlvl | |||
| integer(kind=ilp), | intent(in) | :: | curpbm | |||
| integer(kind=ilp), | intent(in) | :: | prmptr(*) | |||
| integer(kind=ilp), | intent(in) | :: | perm(*) | |||
| integer(kind=ilp), | intent(in) | :: | givptr(*) | |||
| integer(kind=ilp), | intent(in) | :: | givcol(2,*) | |||
| real(kind=dp), | intent(in) | :: | givnum(2,*) | |||
| real(kind=dp), | intent(in) | :: | q(*) | |||
| integer(kind=ilp), | intent(in) | :: | qptr(*) | |||
| real(kind=dp), | intent(out) | :: | z(*) | |||
| real(kind=dp), | intent(out) | :: | ztemp(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | tlvls | |||
| integer(kind=ilp), | intent(in) | :: | curlvl | |||
| integer(kind=ilp), | intent(in) | :: | curpbm | |||
| integer(kind=ilp), | intent(in) | :: | prmptr(*) | |||
| integer(kind=ilp), | intent(in) | :: | perm(*) | |||
| integer(kind=ilp), | intent(in) | :: | givptr(*) | |||
| integer(kind=ilp), | intent(in) | :: | givcol(2,*) | |||
| real(kind=sp), | intent(in) | :: | givnum(2,*) | |||
| real(kind=sp), | intent(in) | :: | q(*) | |||
| integer(kind=ilp), | intent(in) | :: | qptr(*) | |||
| real(kind=sp), | intent(out) | :: | z(*) | |||
| real(kind=sp), | intent(out) | :: | ztemp(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
DLAEDA computes the Z vector corresponding to the merge step in the CURLVLth step of the merge process with TLVLS steps for the CURPBMth problem.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | tlvls | |||
| integer(kind=ilp), | intent(in) | :: | curlvl | |||
| integer(kind=ilp), | intent(in) | :: | curpbm | |||
| integer(kind=ilp), | intent(in) | :: | prmptr(*) | |||
| integer(kind=ilp), | intent(in) | :: | perm(*) | |||
| integer(kind=ilp), | intent(in) | :: | givptr(*) | |||
| integer(kind=ilp), | intent(in) | :: | givcol(2,*) | |||
| real(kind=dp), | intent(in) | :: | givnum(2,*) | |||
| real(kind=dp), | intent(in) | :: | q(*) | |||
| integer(kind=ilp), | intent(in) | :: | qptr(*) | |||
| real(kind=dp), | intent(out) | :: | z(*) | |||
| real(kind=dp), | intent(out) | :: | ztemp(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
SLAEDA computes the Z vector corresponding to the merge step in the CURLVLth step of the merge process with TLVLS steps for the CURPBMth problem.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | tlvls | |||
| integer(kind=ilp), | intent(in) | :: | curlvl | |||
| integer(kind=ilp), | intent(in) | :: | curpbm | |||
| integer(kind=ilp), | intent(in) | :: | prmptr(*) | |||
| integer(kind=ilp), | intent(in) | :: | perm(*) | |||
| integer(kind=ilp), | intent(in) | :: | givptr(*) | |||
| integer(kind=ilp), | intent(in) | :: | givcol(2,*) | |||
| real(kind=sp), | intent(in) | :: | givnum(2,*) | |||
| real(kind=sp), | intent(in) | :: | q(*) | |||
| integer(kind=ilp), | intent(in) | :: | qptr(*) | |||
| real(kind=sp), | intent(out) | :: | z(*) | |||
| real(kind=sp), | intent(out) | :: | ztemp(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
LAEIN uses inverse iteration to find a right or left eigenvector corresponding to the eigenvalue W of a complex upper Hessenberg matrix H.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| logical(kind=lk), | intent(in) | :: | rightv | |||
| logical(kind=lk), | intent(in) | :: | noinit | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=sp), | intent(in) | :: | h(ldh,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldh | |||
| complex(kind=sp), | intent(in) | :: | w | |||
| complex(kind=sp), | intent(inout) | :: | v(*) | |||
| complex(kind=sp), | intent(out) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| real(kind=sp), | intent(out) | :: | rwork(*) | |||
| real(kind=sp), | intent(in) | :: | eps3 | |||
| real(kind=sp), | intent(in) | :: | smlnum | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| logical(kind=lk), | intent(in) | :: | rightv | |||
| logical(kind=lk), | intent(in) | :: | noinit | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=dp), | intent(in) | :: | h(ldh,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldh | |||
| real(kind=dp), | intent(in) | :: | wr | |||
| real(kind=dp), | intent(in) | :: | wi | |||
| real(kind=dp), | intent(inout) | :: | vr(*) | |||
| real(kind=dp), | intent(inout) | :: | vi(*) | |||
| real(kind=dp), | intent(out) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| real(kind=dp), | intent(out) | :: | work(*) | |||
| real(kind=dp), | intent(in) | :: | eps3 | |||
| real(kind=dp), | intent(in) | :: | smlnum | |||
| real(kind=dp), | intent(in) | :: | bignum | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| logical(kind=lk), | intent(in) | :: | rightv | |||
| logical(kind=lk), | intent(in) | :: | noinit | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=sp), | intent(in) | :: | h(ldh,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldh | |||
| real(kind=sp), | intent(in) | :: | wr | |||
| real(kind=sp), | intent(in) | :: | wi | |||
| real(kind=sp), | intent(inout) | :: | vr(*) | |||
| real(kind=sp), | intent(inout) | :: | vi(*) | |||
| real(kind=sp), | intent(out) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| real(kind=sp), | intent(out) | :: | work(*) | |||
| real(kind=sp), | intent(in) | :: | eps3 | |||
| real(kind=sp), | intent(in) | :: | smlnum | |||
| real(kind=sp), | intent(in) | :: | bignum | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| logical(kind=lk), | intent(in) | :: | rightv | |||
| logical(kind=lk), | intent(in) | :: | noinit | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=dp), | intent(in) | :: | h(ldh,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldh | |||
| complex(kind=dp), | intent(in) | :: | w | |||
| complex(kind=dp), | intent(inout) | :: | v(*) | |||
| complex(kind=dp), | intent(out) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| real(kind=dp), | intent(out) | :: | rwork(*) | |||
| real(kind=dp), | intent(in) | :: | eps3 | |||
| real(kind=dp), | intent(in) | :: | smlnum | |||
| integer(kind=ilp), | intent(out) | :: | info |
CLAEIN uses inverse iteration to find a right or left eigenvector corresponding to the eigenvalue W of a complex upper Hessenberg matrix H.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| logical(kind=lk), | intent(in) | :: | rightv | |||
| logical(kind=lk), | intent(in) | :: | noinit | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=sp), | intent(in) | :: | h(ldh,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldh | |||
| complex(kind=sp), | intent(in) | :: | w | |||
| complex(kind=sp), | intent(inout) | :: | v(*) | |||
| complex(kind=sp), | intent(out) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| real(kind=sp), | intent(out) | :: | rwork(*) | |||
| real(kind=sp), | intent(in) | :: | eps3 | |||
| real(kind=sp), | intent(in) | :: | smlnum | |||
| integer(kind=ilp), | intent(out) | :: | info |
DLAEIN uses inverse iteration to find a right or left eigenvector corresponding to the eigenvalue (WR,WI) of a real upper Hessenberg matrix H.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| logical(kind=lk), | intent(in) | :: | rightv | |||
| logical(kind=lk), | intent(in) | :: | noinit | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=dp), | intent(in) | :: | h(ldh,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldh | |||
| real(kind=dp), | intent(in) | :: | wr | |||
| real(kind=dp), | intent(in) | :: | wi | |||
| real(kind=dp), | intent(inout) | :: | vr(*) | |||
| real(kind=dp), | intent(inout) | :: | vi(*) | |||
| real(kind=dp), | intent(out) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| real(kind=dp), | intent(out) | :: | work(*) | |||
| real(kind=dp), | intent(in) | :: | eps3 | |||
| real(kind=dp), | intent(in) | :: | smlnum | |||
| real(kind=dp), | intent(in) | :: | bignum | |||
| integer(kind=ilp), | intent(out) | :: | info |
SLAEIN uses inverse iteration to find a right or left eigenvector corresponding to the eigenvalue (WR,WI) of a real upper Hessenberg matrix H.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| logical(kind=lk), | intent(in) | :: | rightv | |||
| logical(kind=lk), | intent(in) | :: | noinit | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=sp), | intent(in) | :: | h(ldh,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldh | |||
| real(kind=sp), | intent(in) | :: | wr | |||
| real(kind=sp), | intent(in) | :: | wi | |||
| real(kind=sp), | intent(inout) | :: | vr(*) | |||
| real(kind=sp), | intent(inout) | :: | vi(*) | |||
| real(kind=sp), | intent(out) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| real(kind=sp), | intent(out) | :: | work(*) | |||
| real(kind=sp), | intent(in) | :: | eps3 | |||
| real(kind=sp), | intent(in) | :: | smlnum | |||
| real(kind=sp), | intent(in) | :: | bignum | |||
| integer(kind=ilp), | intent(out) | :: | info |
ZLAEIN uses inverse iteration to find a right or left eigenvector corresponding to the eigenvalue W of a complex upper Hessenberg matrix H.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| logical(kind=lk), | intent(in) | :: | rightv | |||
| logical(kind=lk), | intent(in) | :: | noinit | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=dp), | intent(in) | :: | h(ldh,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldh | |||
| complex(kind=dp), | intent(in) | :: | w | |||
| complex(kind=dp), | intent(inout) | :: | v(*) | |||
| complex(kind=dp), | intent(out) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| real(kind=dp), | intent(out) | :: | rwork(*) | |||
| real(kind=dp), | intent(in) | :: | eps3 | |||
| real(kind=dp), | intent(in) | :: | smlnum | |||
| integer(kind=ilp), | intent(out) | :: | info |
LAESY computes the eigendecomposition of a 2-by-2 symmetric matrix ( ( A, B );( B, C ) ) provided the norm of the matrix of eigenvectors is larger than some threshold value. RT1 is the eigenvalue of larger absolute value, and RT2 of smaller absolute value. If the eigenvectors are computed, then on return ( CS1, SN1 ) is the unit eigenvector for RT1, hence [ CS1 SN1 ] . [ A B ] . [ CS1 -SN1 ] = [ RT1 0 ] [ -SN1 CS1 ] [ B C ] [ SN1 CS1 ] [ 0 RT2 ]
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| complex(kind=sp), | intent(in) | :: | a | |||
| complex(kind=sp), | intent(in) | :: | b | |||
| complex(kind=sp), | intent(in) | :: | c | |||
| complex(kind=sp), | intent(out) | :: | rt1 | |||
| complex(kind=sp), | intent(out) | :: | rt2 | |||
| complex(kind=sp), | intent(out) | :: | evscal | |||
| complex(kind=sp), | intent(out) | :: | cs1 | |||
| complex(kind=sp), | intent(out) | :: | sn1 |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| complex(kind=dp), | intent(in) | :: | a | |||
| complex(kind=dp), | intent(in) | :: | b | |||
| complex(kind=dp), | intent(in) | :: | c | |||
| complex(kind=dp), | intent(out) | :: | rt1 | |||
| complex(kind=dp), | intent(out) | :: | rt2 | |||
| complex(kind=dp), | intent(out) | :: | evscal | |||
| complex(kind=dp), | intent(out) | :: | cs1 | |||
| complex(kind=dp), | intent(out) | :: | sn1 |
CLAESY computes the eigendecomposition of a 2-by-2 symmetric matrix ( ( A, B );( B, C ) ) provided the norm of the matrix of eigenvectors is larger than some threshold value. RT1 is the eigenvalue of larger absolute value, and RT2 of smaller absolute value. If the eigenvectors are computed, then on return ( CS1, SN1 ) is the unit eigenvector for RT1, hence [ CS1 SN1 ] . [ A B ] . [ CS1 -SN1 ] = [ RT1 0 ] [ -SN1 CS1 ] [ B C ] [ SN1 CS1 ] [ 0 RT2 ]
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| complex(kind=sp), | intent(in) | :: | a | |||
| complex(kind=sp), | intent(in) | :: | b | |||
| complex(kind=sp), | intent(in) | :: | c | |||
| complex(kind=sp), | intent(out) | :: | rt1 | |||
| complex(kind=sp), | intent(out) | :: | rt2 | |||
| complex(kind=sp), | intent(out) | :: | evscal | |||
| complex(kind=sp), | intent(out) | :: | cs1 | |||
| complex(kind=sp), | intent(out) | :: | sn1 |
ZLAESY computes the eigendecomposition of a 2-by-2 symmetric matrix ( ( A, B );( B, C ) ) provided the norm of the matrix of eigenvectors is larger than some threshold value. RT1 is the eigenvalue of larger absolute value, and RT2 of smaller absolute value. If the eigenvectors are computed, then on return ( CS1, SN1 ) is the unit eigenvector for RT1, hence [ CS1 SN1 ] . [ A B ] . [ CS1 -SN1 ] = [ RT1 0 ] [ -SN1 CS1 ] [ B C ] [ SN1 CS1 ] [ 0 RT2 ]
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| complex(kind=dp), | intent(in) | :: | a | |||
| complex(kind=dp), | intent(in) | :: | b | |||
| complex(kind=dp), | intent(in) | :: | c | |||
| complex(kind=dp), | intent(out) | :: | rt1 | |||
| complex(kind=dp), | intent(out) | :: | rt2 | |||
| complex(kind=dp), | intent(out) | :: | evscal | |||
| complex(kind=dp), | intent(out) | :: | cs1 | |||
| complex(kind=dp), | intent(out) | :: | sn1 |
LAEXC swaps adjacent diagonal blocks T11 and T22 of order 1 or 2 in an upper quasi-triangular matrix T by an orthogonal similarity transformation. T must be in Schur canonical form, that is, block upper triangular with 1-by-1 and 2-by-2 diagonal blocks; each 2-by-2 diagonal block has its diagonal elements equal and its off-diagonal elements of opposite sign.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| logical(kind=lk), | intent(in) | :: | wantq | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=dp), | intent(inout) | :: | t(ldt,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldt | |||
| real(kind=dp), | intent(inout) | :: | q(ldq,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldq | |||
| integer(kind=ilp), | intent(in) | :: | j1 | |||
| integer(kind=ilp), | intent(in) | :: | n1 | |||
| integer(kind=ilp), | intent(in) | :: | n2 | |||
| real(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| logical(kind=lk), | intent(in) | :: | wantq | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=sp), | intent(inout) | :: | t(ldt,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldt | |||
| real(kind=sp), | intent(inout) | :: | q(ldq,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldq | |||
| integer(kind=ilp), | intent(in) | :: | j1 | |||
| integer(kind=ilp), | intent(in) | :: | n1 | |||
| integer(kind=ilp), | intent(in) | :: | n2 | |||
| real(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
DLAEXC swaps adjacent diagonal blocks T11 and T22 of order 1 or 2 in an upper quasi-triangular matrix T by an orthogonal similarity transformation. T must be in Schur canonical form, that is, block upper triangular with 1-by-1 and 2-by-2 diagonal blocks; each 2-by-2 diagonal block has its diagonal elements equal and its off-diagonal elements of opposite sign.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| logical(kind=lk), | intent(in) | :: | wantq | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=dp), | intent(inout) | :: | t(ldt,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldt | |||
| real(kind=dp), | intent(inout) | :: | q(ldq,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldq | |||
| integer(kind=ilp), | intent(in) | :: | j1 | |||
| integer(kind=ilp), | intent(in) | :: | n1 | |||
| integer(kind=ilp), | intent(in) | :: | n2 | |||
| real(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
SLAEXC swaps adjacent diagonal blocks T11 and T22 of order 1 or 2 in an upper quasi-triangular matrix T by an orthogonal similarity transformation. T must be in Schur canonical form, that is, block upper triangular with 1-by-1 and 2-by-2 diagonal blocks; each 2-by-2 diagonal block has its diagonal elements equal and its off-diagonal elements of opposite sign.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| logical(kind=lk), | intent(in) | :: | wantq | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=sp), | intent(inout) | :: | t(ldt,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldt | |||
| real(kind=sp), | intent(inout) | :: | q(ldq,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldq | |||
| integer(kind=ilp), | intent(in) | :: | j1 | |||
| integer(kind=ilp), | intent(in) | :: | n1 | |||
| integer(kind=ilp), | intent(in) | :: | n2 | |||
| real(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
LAGTF factorizes the matrix (T - lambdaI), where T is an n by n tridiagonal matrix and lambda is a scalar, as T - lambdaI = PLU, where P is a permutation matrix, L is a unit lower tridiagonal matrix with at most one non-zero sub-diagonal elements per column and U is an upper triangular matrix with at most two non-zero super-diagonal elements per column. The factorization is obtained by Gaussian elimination with partial pivoting and implicit row scaling. The parameter LAMBDA is included in the routine so that LAGTF may be used, in conjunction with DLAGTS, to obtain eigenvectors of T by inverse iteration.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=dp), | intent(inout) | :: | a(*) | |||
| real(kind=dp), | intent(in) | :: | lambda | |||
| real(kind=dp), | intent(inout) | :: | b(*) | |||
| real(kind=dp), | intent(inout) | :: | c(*) | |||
| real(kind=dp), | intent(in) | :: | tol | |||
| real(kind=dp), | intent(out) | :: | d(*) | |||
| integer(kind=ilp), | intent(out) | :: | in(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=sp), | intent(inout) | :: | a(*) | |||
| real(kind=sp), | intent(in) | :: | lambda | |||
| real(kind=sp), | intent(inout) | :: | b(*) | |||
| real(kind=sp), | intent(inout) | :: | c(*) | |||
| real(kind=sp), | intent(in) | :: | tol | |||
| real(kind=sp), | intent(out) | :: | d(*) | |||
| integer(kind=ilp), | intent(out) | :: | in(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
DLAGTF factorizes the matrix (T - lambdaI), where T is an n by n tridiagonal matrix and lambda is a scalar, as T - lambdaI = PLU, where P is a permutation matrix, L is a unit lower tridiagonal matrix with at most one non-zero sub-diagonal elements per column and U is an upper triangular matrix with at most two non-zero super-diagonal elements per column. The factorization is obtained by Gaussian elimination with partial pivoting and implicit row scaling. The parameter LAMBDA is included in the routine so that DLAGTF may be used, in conjunction with DLAGTS, to obtain eigenvectors of T by inverse iteration.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=dp), | intent(inout) | :: | a(*) | |||
| real(kind=dp), | intent(in) | :: | lambda | |||
| real(kind=dp), | intent(inout) | :: | b(*) | |||
| real(kind=dp), | intent(inout) | :: | c(*) | |||
| real(kind=dp), | intent(in) | :: | tol | |||
| real(kind=dp), | intent(out) | :: | d(*) | |||
| integer(kind=ilp), | intent(out) | :: | in(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
SLAGTF factorizes the matrix (T - lambdaI), where T is an n by n tridiagonal matrix and lambda is a scalar, as T - lambdaI = PLU, where P is a permutation matrix, L is a unit lower tridiagonal matrix with at most one non-zero sub-diagonal elements per column and U is an upper triangular matrix with at most two non-zero super-diagonal elements per column. The factorization is obtained by Gaussian elimination with partial pivoting and implicit row scaling. The parameter LAMBDA is included in the routine so that SLAGTF may be used, in conjunction with SLAGTS, to obtain eigenvectors of T by inverse iteration.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=sp), | intent(inout) | :: | a(*) | |||
| real(kind=sp), | intent(in) | :: | lambda | |||
| real(kind=sp), | intent(inout) | :: | b(*) | |||
| real(kind=sp), | intent(inout) | :: | c(*) | |||
| real(kind=sp), | intent(in) | :: | tol | |||
| real(kind=sp), | intent(out) | :: | d(*) | |||
| integer(kind=ilp), | intent(out) | :: | in(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
LAGTM performs a matrix-vector product of the form B := alpha * A * X + beta * B where A is a tridiagonal matrix of order N, B and X are N by NRHS matrices, and alpha and beta are real scalars, each of which may be 0., 1., or -1.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | trans | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| real(kind=sp), | intent(in) | :: | alpha | |||
| complex(kind=sp), | intent(in) | :: | dl(*) | |||
| complex(kind=sp), | intent(in) | :: | d(*) | |||
| complex(kind=sp), | intent(in) | :: | du(*) | |||
| complex(kind=sp), | intent(in) | :: | x(ldx,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldx | |||
| real(kind=sp), | intent(in) | :: | beta | |||
| complex(kind=sp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | trans | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| real(kind=dp), | intent(in) | :: | alpha | |||
| real(kind=dp), | intent(in) | :: | dl(*) | |||
| real(kind=dp), | intent(in) | :: | d(*) | |||
| real(kind=dp), | intent(in) | :: | du(*) | |||
| real(kind=dp), | intent(in) | :: | x(ldx,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldx | |||
| real(kind=dp), | intent(in) | :: | beta | |||
| real(kind=dp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | trans | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| real(kind=sp), | intent(in) | :: | alpha | |||
| real(kind=sp), | intent(in) | :: | dl(*) | |||
| real(kind=sp), | intent(in) | :: | d(*) | |||
| real(kind=sp), | intent(in) | :: | du(*) | |||
| real(kind=sp), | intent(in) | :: | x(ldx,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldx | |||
| real(kind=sp), | intent(in) | :: | beta | |||
| real(kind=sp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | trans | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| real(kind=dp), | intent(in) | :: | alpha | |||
| complex(kind=dp), | intent(in) | :: | dl(*) | |||
| complex(kind=dp), | intent(in) | :: | d(*) | |||
| complex(kind=dp), | intent(in) | :: | du(*) | |||
| complex(kind=dp), | intent(in) | :: | x(ldx,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldx | |||
| real(kind=dp), | intent(in) | :: | beta | |||
| complex(kind=dp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb |
CLAGTM performs a matrix-vector product of the form B := alpha * A * X + beta * B where A is a tridiagonal matrix of order N, B and X are N by NRHS matrices, and alpha and beta are real scalars, each of which may be 0., 1., or -1.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | trans | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| real(kind=sp), | intent(in) | :: | alpha | |||
| complex(kind=sp), | intent(in) | :: | dl(*) | |||
| complex(kind=sp), | intent(in) | :: | d(*) | |||
| complex(kind=sp), | intent(in) | :: | du(*) | |||
| complex(kind=sp), | intent(in) | :: | x(ldx,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldx | |||
| real(kind=sp), | intent(in) | :: | beta | |||
| complex(kind=sp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb |
DLAGTM performs a matrix-vector product of the form B := alpha * A * X + beta * B where A is a tridiagonal matrix of order N, B and X are N by NRHS matrices, and alpha and beta are real scalars, each of which may be 0., 1., or -1.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | trans | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| real(kind=dp), | intent(in) | :: | alpha | |||
| real(kind=dp), | intent(in) | :: | dl(*) | |||
| real(kind=dp), | intent(in) | :: | d(*) | |||
| real(kind=dp), | intent(in) | :: | du(*) | |||
| real(kind=dp), | intent(in) | :: | x(ldx,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldx | |||
| real(kind=dp), | intent(in) | :: | beta | |||
| real(kind=dp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb |
SLAGTM performs a matrix-vector product of the form B := alpha * A * X + beta * B where A is a tridiagonal matrix of order N, B and X are N by NRHS matrices, and alpha and beta are real scalars, each of which may be 0., 1., or -1.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | trans | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| real(kind=sp), | intent(in) | :: | alpha | |||
| real(kind=sp), | intent(in) | :: | dl(*) | |||
| real(kind=sp), | intent(in) | :: | d(*) | |||
| real(kind=sp), | intent(in) | :: | du(*) | |||
| real(kind=sp), | intent(in) | :: | x(ldx,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldx | |||
| real(kind=sp), | intent(in) | :: | beta | |||
| real(kind=sp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb |
ZLAGTM performs a matrix-vector product of the form B := alpha * A * X + beta * B where A is a tridiagonal matrix of order N, B and X are N by NRHS matrices, and alpha and beta are real scalars, each of which may be 0., 1., or -1.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | trans | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| real(kind=dp), | intent(in) | :: | alpha | |||
| complex(kind=dp), | intent(in) | :: | dl(*) | |||
| complex(kind=dp), | intent(in) | :: | d(*) | |||
| complex(kind=dp), | intent(in) | :: | du(*) | |||
| complex(kind=dp), | intent(in) | :: | x(ldx,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldx | |||
| real(kind=dp), | intent(in) | :: | beta | |||
| complex(kind=dp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb |
LAGTS may be used to solve one of the systems of equations (T - lambdaI)x = y or (T - lambdaI)Tx = y, where T is an n by n tridiagonal matrix, for x, following the factorization of (T - lambdaI) as (T - lambdaI) = PLU , by routine DLAGTF. The choice of equation to be solved is controlled by the argument JOB, and in each case there is an option to perturb zero or very small diagonal elements of U, this option being intended for use in applications such as inverse iteration.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | job | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=dp), | intent(in) | :: | a(*) | |||
| real(kind=dp), | intent(in) | :: | b(*) | |||
| real(kind=dp), | intent(in) | :: | c(*) | |||
| real(kind=dp), | intent(in) | :: | d(*) | |||
| integer(kind=ilp), | intent(in) | :: | in(*) | |||
| real(kind=dp), | intent(inout) | :: | y(*) | |||
| real(kind=dp), | intent(inout) | :: | tol | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | job | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=sp), | intent(in) | :: | a(*) | |||
| real(kind=sp), | intent(in) | :: | b(*) | |||
| real(kind=sp), | intent(in) | :: | c(*) | |||
| real(kind=sp), | intent(in) | :: | d(*) | |||
| integer(kind=ilp), | intent(in) | :: | in(*) | |||
| real(kind=sp), | intent(inout) | :: | y(*) | |||
| real(kind=sp), | intent(inout) | :: | tol | |||
| integer(kind=ilp), | intent(out) | :: | info |
DLAGTS may be used to solve one of the systems of equations (T - lambdaI)x = y or (T - lambdaI)Tx = y, where T is an n by n tridiagonal matrix, for x, following the factorization of (T - lambdaI) as (T - lambdaI) = PLU , by routine DLAGTF. The choice of equation to be solved is controlled by the argument JOB, and in each case there is an option to perturb zero or very small diagonal elements of U, this option being intended for use in applications such as inverse iteration.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | job | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=dp), | intent(in) | :: | a(*) | |||
| real(kind=dp), | intent(in) | :: | b(*) | |||
| real(kind=dp), | intent(in) | :: | c(*) | |||
| real(kind=dp), | intent(in) | :: | d(*) | |||
| integer(kind=ilp), | intent(in) | :: | in(*) | |||
| real(kind=dp), | intent(inout) | :: | y(*) | |||
| real(kind=dp), | intent(inout) | :: | tol | |||
| integer(kind=ilp), | intent(out) | :: | info |
SLAGTS may be used to solve one of the systems of equations (T - lambdaI)x = y or (T - lambdaI)Tx = y, where T is an n by n tridiagonal matrix, for x, following the factorization of (T - lambdaI) as (T - lambdaI) = PLU , by routine SLAGTF. The choice of equation to be solved is controlled by the argument JOB, and in each case there is an option to perturb zero or very small diagonal elements of U, this option being intended for use in applications such as inverse iteration.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | job | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=sp), | intent(in) | :: | a(*) | |||
| real(kind=sp), | intent(in) | :: | b(*) | |||
| real(kind=sp), | intent(in) | :: | c(*) | |||
| real(kind=sp), | intent(in) | :: | d(*) | |||
| integer(kind=ilp), | intent(in) | :: | in(*) | |||
| real(kind=sp), | intent(inout) | :: | y(*) | |||
| real(kind=sp), | intent(inout) | :: | tol | |||
| integer(kind=ilp), | intent(out) | :: | info |
LAHEF computes a partial factorization of a complex Hermitian matrix A using the Bunch-Kaufman diagonal pivoting method. The partial factorization has the form: A = ( I U12 ) ( A11 0 ) ( I 0 ) if UPLO = 'U', or: ( 0 U22 ) ( 0 D ) ( U12H U22H ) A = ( L11 0 ) ( D 0 ) ( L11H L21H ) if UPLO = 'L' ( L21 I ) ( 0 A22 ) ( 0 I ) where the order of D is at most NB. The actual order is returned in the argument KB, and is either NB or NB-1, or N if N <= NB. Note that U**H denotes the conjugate transpose of U. LAHEF is an auxiliary routine called by CHETRF. It uses blocked code (calling Level 3 BLAS) to update the submatrix A11 (if UPLO = 'U') or A22 (if UPLO = 'L').
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nb | |||
| integer(kind=ilp), | intent(out) | :: | kb | |||
| complex(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| integer(kind=ilp), | intent(out) | :: | ipiv(*) | |||
| complex(kind=sp), | intent(out) | :: | w(ldw,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldw | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nb | |||
| integer(kind=ilp), | intent(out) | :: | kb | |||
| complex(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| integer(kind=ilp), | intent(out) | :: | ipiv(*) | |||
| complex(kind=dp), | intent(out) | :: | w(ldw,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldw | |||
| integer(kind=ilp), | intent(out) | :: | info |
CLAHEF computes a partial factorization of a complex Hermitian matrix A using the Bunch-Kaufman diagonal pivoting method. The partial factorization has the form: A = ( I U12 ) ( A11 0 ) ( I 0 ) if UPLO = 'U', or: ( 0 U22 ) ( 0 D ) ( U12H U22H ) A = ( L11 0 ) ( D 0 ) ( L11H L21H ) if UPLO = 'L' ( L21 I ) ( 0 A22 ) ( 0 I ) where the order of D is at most NB. The actual order is returned in the argument KB, and is either NB or NB-1, or N if N <= NB. Note that U**H denotes the conjugate transpose of U. CLAHEF is an auxiliary routine called by CHETRF. It uses blocked code (calling Level 3 BLAS) to update the submatrix A11 (if UPLO = 'U') or A22 (if UPLO = 'L').
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nb | |||
| integer(kind=ilp), | intent(out) | :: | kb | |||
| complex(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| integer(kind=ilp), | intent(out) | :: | ipiv(*) | |||
| complex(kind=sp), | intent(out) | :: | w(ldw,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldw | |||
| integer(kind=ilp), | intent(out) | :: | info |
ZLAHEF computes a partial factorization of a complex Hermitian matrix A using the Bunch-Kaufman diagonal pivoting method. The partial factorization has the form: A = ( I U12 ) ( A11 0 ) ( I 0 ) if UPLO = 'U', or: ( 0 U22 ) ( 0 D ) ( U12H U22H ) A = ( L11 0 ) ( D 0 ) ( L11H L21H ) if UPLO = 'L' ( L21 I ) ( 0 A22 ) ( 0 I ) where the order of D is at most NB. The actual order is returned in the argument KB, and is either NB or NB-1, or N if N <= NB. Note that U**H denotes the conjugate transpose of U. ZLAHEF is an auxiliary routine called by ZHETRF. It uses blocked code (calling Level 3 BLAS) to update the submatrix A11 (if UPLO = 'U') or A22 (if UPLO = 'L').
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nb | |||
| integer(kind=ilp), | intent(out) | :: | kb | |||
| complex(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| integer(kind=ilp), | intent(out) | :: | ipiv(*) | |||
| complex(kind=dp), | intent(out) | :: | w(ldw,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldw | |||
| integer(kind=ilp), | intent(out) | :: | info |
LAHEF_AA factorizes a panel of a complex hermitian matrix A using the Aasen's algorithm. The panel consists of a set of NB rows of A when UPLO is U, or a set of NB columns when UPLO is L. In order to factorize the panel, the Aasen's algorithm requires the last row, or column, of the previous panel. The first row, or column, of A is set to be the first row, or column, of an identity matrix, which is used to factorize the first panel. The resulting J-th row of U, or J-th column of L, is stored in the (J-1)-th row, or column, of A (without the unit diagonals), while the diagonal and subdiagonal of A are overwritten by those of T.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | j1 | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | nb | |||
| complex(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| integer(kind=ilp), | intent(out) | :: | ipiv(*) | |||
| complex(kind=sp), | intent(inout) | :: | h(ldh,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldh | |||
| complex(kind=sp), | intent(out) | :: | work(*) |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | j1 | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | nb | |||
| complex(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| integer(kind=ilp), | intent(out) | :: | ipiv(*) | |||
| complex(kind=dp), | intent(inout) | :: | h(ldh,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldh | |||
| complex(kind=dp), | intent(out) | :: | work(*) |
CLAHEF_AA factorizes a panel of a complex hermitian matrix A using the Aasen's algorithm. The panel consists of a set of NB rows of A when UPLO is U, or a set of NB columns when UPLO is L. In order to factorize the panel, the Aasen's algorithm requires the last row, or column, of the previous panel. The first row, or column, of A is set to be the first row, or column, of an identity matrix, which is used to factorize the first panel. The resulting J-th row of U, or J-th column of L, is stored in the (J-1)-th row, or column, of A (without the unit diagonals), while the diagonal and subdiagonal of A are overwritten by those of T.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | j1 | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | nb | |||
| complex(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| integer(kind=ilp), | intent(out) | :: | ipiv(*) | |||
| complex(kind=sp), | intent(inout) | :: | h(ldh,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldh | |||
| complex(kind=sp), | intent(out) | :: | work(*) |
DLAHEF_AA factorizes a panel of a complex hermitian matrix A using the Aasen's algorithm. The panel consists of a set of NB rows of A when UPLO is U, or a set of NB columns when UPLO is L. In order to factorize the panel, the Aasen's algorithm requires the last row, or column, of the previous panel. The first row, or column, of A is set to be the first row, or column, of an identity matrix, which is used to factorize the first panel. The resulting J-th row of U, or J-th column of L, is stored in the (J-1)-th row, or column, of A (without the unit diagonals), while the diagonal and subdiagonal of A are overwritten by those of T.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | j1 | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | nb | |||
| complex(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| integer(kind=ilp), | intent(out) | :: | ipiv(*) | |||
| complex(kind=dp), | intent(inout) | :: | h(ldh,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldh | |||
| complex(kind=dp), | intent(out) | :: | work(*) |
LAHEF_RK computes a partial factorization of a complex Hermitian matrix A using the bounded Bunch-Kaufman (rook) diagonal pivoting method. The partial factorization has the form: A = ( I U12 ) ( A11 0 ) ( I 0 ) if UPLO = 'U', or: ( 0 U22 ) ( 0 D ) ( U12H U22H ) A = ( L11 0 ) ( D 0 ) ( L11H L21H ) if UPLO = 'L', ( L21 I ) ( 0 A22 ) ( 0 I ) where the order of D is at most NB. The actual order is returned in the argument KB, and is either NB or NB-1, or N if N <= NB. LAHEF_RK is an auxiliary routine called by CHETRF_RK. It uses blocked code (calling Level 3 BLAS) to update the submatrix A11 (if UPLO = 'U') or A22 (if UPLO = 'L').
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nb | |||
| integer(kind=ilp), | intent(out) | :: | kb | |||
| complex(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=sp), | intent(out) | :: | e(*) | |||
| integer(kind=ilp), | intent(out) | :: | ipiv(*) | |||
| complex(kind=sp), | intent(out) | :: | w(ldw,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldw | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nb | |||
| integer(kind=ilp), | intent(out) | :: | kb | |||
| complex(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=dp), | intent(out) | :: | e(*) | |||
| integer(kind=ilp), | intent(out) | :: | ipiv(*) | |||
| complex(kind=dp), | intent(out) | :: | w(ldw,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldw | |||
| integer(kind=ilp), | intent(out) | :: | info |
CLAHEF_RK computes a partial factorization of a complex Hermitian matrix A using the bounded Bunch-Kaufman (rook) diagonal pivoting method. The partial factorization has the form: A = ( I U12 ) ( A11 0 ) ( I 0 ) if UPLO = 'U', or: ( 0 U22 ) ( 0 D ) ( U12H U22H ) A = ( L11 0 ) ( D 0 ) ( L11H L21H ) if UPLO = 'L', ( L21 I ) ( 0 A22 ) ( 0 I ) where the order of D is at most NB. The actual order is returned in the argument KB, and is either NB or NB-1, or N if N <= NB. CLAHEF_RK is an auxiliary routine called by CHETRF_RK. It uses blocked code (calling Level 3 BLAS) to update the submatrix A11 (if UPLO = 'U') or A22 (if UPLO = 'L').
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nb | |||
| integer(kind=ilp), | intent(out) | :: | kb | |||
| complex(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=sp), | intent(out) | :: | e(*) | |||
| integer(kind=ilp), | intent(out) | :: | ipiv(*) | |||
| complex(kind=sp), | intent(out) | :: | w(ldw,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldw | |||
| integer(kind=ilp), | intent(out) | :: | info |
ZLAHEF_RK computes a partial factorization of a complex Hermitian matrix A using the bounded Bunch-Kaufman (rook) diagonal pivoting method. The partial factorization has the form: A = ( I U12 ) ( A11 0 ) ( I 0 ) if UPLO = 'U', or: ( 0 U22 ) ( 0 D ) ( U12H U22H ) A = ( L11 0 ) ( D 0 ) ( L11H L21H ) if UPLO = 'L', ( L21 I ) ( 0 A22 ) ( 0 I ) where the order of D is at most NB. The actual order is returned in the argument KB, and is either NB or NB-1, or N if N <= NB. ZLAHEF_RK is an auxiliary routine called by ZHETRF_RK. It uses blocked code (calling Level 3 BLAS) to update the submatrix A11 (if UPLO = 'U') or A22 (if UPLO = 'L').
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nb | |||
| integer(kind=ilp), | intent(out) | :: | kb | |||
| complex(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=dp), | intent(out) | :: | e(*) | |||
| integer(kind=ilp), | intent(out) | :: | ipiv(*) | |||
| complex(kind=dp), | intent(out) | :: | w(ldw,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldw | |||
| integer(kind=ilp), | intent(out) | :: | info |
LAHEF_ROOK computes a partial factorization of a complex Hermitian matrix A using the bounded Bunch-Kaufman ("rook") diagonal pivoting method. The partial factorization has the form: A = ( I U12 ) ( A11 0 ) ( I 0 ) if UPLO = 'U', or: ( 0 U22 ) ( 0 D ) ( U12H U22H ) A = ( L11 0 ) ( D 0 ) ( L11H L21H ) if UPLO = 'L' ( L21 I ) ( 0 A22 ) ( 0 I ) where the order of D is at most NB. The actual order is returned in the argument KB, and is either NB or NB-1, or N if N <= NB. Note that U**H denotes the conjugate transpose of U. LAHEF_ROOK is an auxiliary routine called by CHETRF_ROOK. It uses blocked code (calling Level 3 BLAS) to update the submatrix A11 (if UPLO = 'U') or A22 (if UPLO = 'L').
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nb | |||
| integer(kind=ilp), | intent(out) | :: | kb | |||
| complex(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| integer(kind=ilp), | intent(out) | :: | ipiv(*) | |||
| complex(kind=sp), | intent(out) | :: | w(ldw,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldw | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nb | |||
| integer(kind=ilp), | intent(out) | :: | kb | |||
| complex(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| integer(kind=ilp), | intent(out) | :: | ipiv(*) | |||
| complex(kind=dp), | intent(out) | :: | w(ldw,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldw | |||
| integer(kind=ilp), | intent(out) | :: | info |
CLAHEF_ROOK computes a partial factorization of a complex Hermitian matrix A using the bounded Bunch-Kaufman ("rook") diagonal pivoting method. The partial factorization has the form: A = ( I U12 ) ( A11 0 ) ( I 0 ) if UPLO = 'U', or: ( 0 U22 ) ( 0 D ) ( U12H U22H ) A = ( L11 0 ) ( D 0 ) ( L11H L21H ) if UPLO = 'L' ( L21 I ) ( 0 A22 ) ( 0 I ) where the order of D is at most NB. The actual order is returned in the argument KB, and is either NB or NB-1, or N if N <= NB. Note that U**H denotes the conjugate transpose of U. CLAHEF_ROOK is an auxiliary routine called by CHETRF_ROOK. It uses blocked code (calling Level 3 BLAS) to update the submatrix A11 (if UPLO = 'U') or A22 (if UPLO = 'L').
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nb | |||
| integer(kind=ilp), | intent(out) | :: | kb | |||
| complex(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| integer(kind=ilp), | intent(out) | :: | ipiv(*) | |||
| complex(kind=sp), | intent(out) | :: | w(ldw,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldw | |||
| integer(kind=ilp), | intent(out) | :: | info |
ZLAHEF_ROOK computes a partial factorization of a complex Hermitian matrix A using the bounded Bunch-Kaufman ("rook") diagonal pivoting method. The partial factorization has the form: A = ( I U12 ) ( A11 0 ) ( I 0 ) if UPLO = 'U', or: ( 0 U22 ) ( 0 D ) ( U12H U22H ) A = ( L11 0 ) ( D 0 ) ( L11H L21H ) if UPLO = 'L' ( L21 I ) ( 0 A22 ) ( 0 I ) where the order of D is at most NB. The actual order is returned in the argument KB, and is either NB or NB-1, or N if N <= NB. Note that U**H denotes the conjugate transpose of U. ZLAHEF_ROOK is an auxiliary routine called by ZHETRF_ROOK. It uses blocked code (calling Level 3 BLAS) to update the submatrix A11 (if UPLO = 'U') or A22 (if UPLO = 'L').
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nb | |||
| integer(kind=ilp), | intent(out) | :: | kb | |||
| complex(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| integer(kind=ilp), | intent(out) | :: | ipiv(*) | |||
| complex(kind=dp), | intent(out) | :: | w(ldw,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldw | |||
| integer(kind=ilp), | intent(out) | :: | info |
LAHQR is an auxiliary routine called by CHSEQR to update the eigenvalues and Schur decomposition already computed by CHSEQR, by dealing with the Hessenberg submatrix in rows and columns ILO to IHI.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| logical(kind=lk), | intent(in) | :: | wantt | |||
| logical(kind=lk), | intent(in) | :: | wantz | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | ilo | |||
| integer(kind=ilp), | intent(in) | :: | ihi | |||
| complex(kind=sp), | intent(inout) | :: | h(ldh,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldh | |||
| complex(kind=sp), | intent(out) | :: | w(*) | |||
| integer(kind=ilp), | intent(in) | :: | iloz | |||
| integer(kind=ilp), | intent(in) | :: | ihiz | |||
| complex(kind=sp), | intent(inout) | :: | z(ldz,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldz | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| logical(kind=lk), | intent(in) | :: | wantt | |||
| logical(kind=lk), | intent(in) | :: | wantz | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | ilo | |||
| integer(kind=ilp), | intent(in) | :: | ihi | |||
| real(kind=dp), | intent(inout) | :: | h(ldh,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldh | |||
| real(kind=dp), | intent(out) | :: | wr(*) | |||
| real(kind=dp), | intent(out) | :: | wi(*) | |||
| integer(kind=ilp), | intent(in) | :: | iloz | |||
| integer(kind=ilp), | intent(in) | :: | ihiz | |||
| real(kind=dp), | intent(inout) | :: | z(ldz,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldz | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| logical(kind=lk), | intent(in) | :: | wantt | |||
| logical(kind=lk), | intent(in) | :: | wantz | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | ilo | |||
| integer(kind=ilp), | intent(in) | :: | ihi | |||
| real(kind=sp), | intent(inout) | :: | h(ldh,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldh | |||
| real(kind=sp), | intent(out) | :: | wr(*) | |||
| real(kind=sp), | intent(out) | :: | wi(*) | |||
| integer(kind=ilp), | intent(in) | :: | iloz | |||
| integer(kind=ilp), | intent(in) | :: | ihiz | |||
| real(kind=sp), | intent(inout) | :: | z(ldz,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldz | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| logical(kind=lk), | intent(in) | :: | wantt | |||
| logical(kind=lk), | intent(in) | :: | wantz | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | ilo | |||
| integer(kind=ilp), | intent(in) | :: | ihi | |||
| complex(kind=dp), | intent(inout) | :: | h(ldh,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldh | |||
| complex(kind=dp), | intent(out) | :: | w(*) | |||
| integer(kind=ilp), | intent(in) | :: | iloz | |||
| integer(kind=ilp), | intent(in) | :: | ihiz | |||
| complex(kind=dp), | intent(inout) | :: | z(ldz,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldz | |||
| integer(kind=ilp), | intent(out) | :: | info |
CLAHQR is an auxiliary routine called by CHSEQR to update the eigenvalues and Schur decomposition already computed by CHSEQR, by dealing with the Hessenberg submatrix in rows and columns ILO to IHI.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| logical(kind=lk), | intent(in) | :: | wantt | |||
| logical(kind=lk), | intent(in) | :: | wantz | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | ilo | |||
| integer(kind=ilp), | intent(in) | :: | ihi | |||
| complex(kind=sp), | intent(inout) | :: | h(ldh,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldh | |||
| complex(kind=sp), | intent(out) | :: | w(*) | |||
| integer(kind=ilp), | intent(in) | :: | iloz | |||
| integer(kind=ilp), | intent(in) | :: | ihiz | |||
| complex(kind=sp), | intent(inout) | :: | z(ldz,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldz | |||
| integer(kind=ilp), | intent(out) | :: | info |
DLAHQR is an auxiliary routine called by DHSEQR to update the eigenvalues and Schur decomposition already computed by DHSEQR, by dealing with the Hessenberg submatrix in rows and columns ILO to IHI.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| logical(kind=lk), | intent(in) | :: | wantt | |||
| logical(kind=lk), | intent(in) | :: | wantz | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | ilo | |||
| integer(kind=ilp), | intent(in) | :: | ihi | |||
| real(kind=dp), | intent(inout) | :: | h(ldh,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldh | |||
| real(kind=dp), | intent(out) | :: | wr(*) | |||
| real(kind=dp), | intent(out) | :: | wi(*) | |||
| integer(kind=ilp), | intent(in) | :: | iloz | |||
| integer(kind=ilp), | intent(in) | :: | ihiz | |||
| real(kind=dp), | intent(inout) | :: | z(ldz,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldz | |||
| integer(kind=ilp), | intent(out) | :: | info |
SLAHQR is an auxiliary routine called by SHSEQR to update the eigenvalues and Schur decomposition already computed by SHSEQR, by dealing with the Hessenberg submatrix in rows and columns ILO to IHI.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| logical(kind=lk), | intent(in) | :: | wantt | |||
| logical(kind=lk), | intent(in) | :: | wantz | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | ilo | |||
| integer(kind=ilp), | intent(in) | :: | ihi | |||
| real(kind=sp), | intent(inout) | :: | h(ldh,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldh | |||
| real(kind=sp), | intent(out) | :: | wr(*) | |||
| real(kind=sp), | intent(out) | :: | wi(*) | |||
| integer(kind=ilp), | intent(in) | :: | iloz | |||
| integer(kind=ilp), | intent(in) | :: | ihiz | |||
| real(kind=sp), | intent(inout) | :: | z(ldz,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldz | |||
| integer(kind=ilp), | intent(out) | :: | info |
ZLAHQR is an auxiliary routine called by CHSEQR to update the eigenvalues and Schur decomposition already computed by CHSEQR, by dealing with the Hessenberg submatrix in rows and columns ILO to IHI.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| logical(kind=lk), | intent(in) | :: | wantt | |||
| logical(kind=lk), | intent(in) | :: | wantz | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | ilo | |||
| integer(kind=ilp), | intent(in) | :: | ihi | |||
| complex(kind=dp), | intent(inout) | :: | h(ldh,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldh | |||
| complex(kind=dp), | intent(out) | :: | w(*) | |||
| integer(kind=ilp), | intent(in) | :: | iloz | |||
| integer(kind=ilp), | intent(in) | :: | ihiz | |||
| complex(kind=dp), | intent(inout) | :: | z(ldz,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldz | |||
| integer(kind=ilp), | intent(out) | :: | info |
LAIC1 applies one step of incremental condition estimation in its simplest version: Let x, twonorm(x) = 1, be an approximate singular vector of an j-by-j lower triangular matrix L, such that twonorm(Lx) = sest Then LAIC1 computes sestpr, s, c such that the vector [ sx ] xhat = [ c ] is an approximate singular vector of [ L 0 ] Lhat = [ wH gamma ] in the sense that twonorm(Lhat*xhat) = sestpr. Depending on JOB, an estimate for the largest or smallest singular value is computed. Note that [s c]H and sestpr2 is an eigenpair of the system diag(sest*sest, 0) + [alpha gamma] * [ conjg(alpha) ] [ conjg(gamma) ] where alpha = xH*w.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | job | |||
| integer(kind=ilp), | intent(in) | :: | j | |||
| complex(kind=sp), | intent(in) | :: | x(j) | |||
| real(kind=sp), | intent(in) | :: | sest | |||
| complex(kind=sp), | intent(in) | :: | w(j) | |||
| complex(kind=sp), | intent(in) | :: | gamma | |||
| real(kind=sp), | intent(out) | :: | sestpr | |||
| complex(kind=sp), | intent(out) | :: | s | |||
| complex(kind=sp), | intent(out) | :: | c |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | job | |||
| integer(kind=ilp), | intent(in) | :: | j | |||
| real(kind=dp), | intent(in) | :: | x(j) | |||
| real(kind=dp), | intent(in) | :: | sest | |||
| real(kind=dp), | intent(in) | :: | w(j) | |||
| real(kind=dp), | intent(in) | :: | gamma | |||
| real(kind=dp), | intent(out) | :: | sestpr | |||
| real(kind=dp), | intent(out) | :: | s | |||
| real(kind=dp), | intent(out) | :: | c |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | job | |||
| integer(kind=ilp), | intent(in) | :: | j | |||
| real(kind=sp), | intent(in) | :: | x(j) | |||
| real(kind=sp), | intent(in) | :: | sest | |||
| real(kind=sp), | intent(in) | :: | w(j) | |||
| real(kind=sp), | intent(in) | :: | gamma | |||
| real(kind=sp), | intent(out) | :: | sestpr | |||
| real(kind=sp), | intent(out) | :: | s | |||
| real(kind=sp), | intent(out) | :: | c |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | job | |||
| integer(kind=ilp), | intent(in) | :: | j | |||
| complex(kind=dp), | intent(in) | :: | x(j) | |||
| real(kind=dp), | intent(in) | :: | sest | |||
| complex(kind=dp), | intent(in) | :: | w(j) | |||
| complex(kind=dp), | intent(in) | :: | gamma | |||
| real(kind=dp), | intent(out) | :: | sestpr | |||
| complex(kind=dp), | intent(out) | :: | s | |||
| complex(kind=dp), | intent(out) | :: | c |
CLAIC1 applies one step of incremental condition estimation in its simplest version: Let x, twonorm(x) = 1, be an approximate singular vector of an j-by-j lower triangular matrix L, such that twonorm(Lx) = sest Then CLAIC1 computes sestpr, s, c such that the vector [ sx ] xhat = [ c ] is an approximate singular vector of [ L 0 ] Lhat = [ wH gamma ] in the sense that twonorm(Lhat*xhat) = sestpr. Depending on JOB, an estimate for the largest or smallest singular value is computed. Note that [s c]H and sestpr2 is an eigenpair of the system diag(sest*sest, 0) + [alpha gamma] * [ conjg(alpha) ] [ conjg(gamma) ] where alpha = xH*w.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | job | |||
| integer(kind=ilp), | intent(in) | :: | j | |||
| complex(kind=sp), | intent(in) | :: | x(j) | |||
| real(kind=sp), | intent(in) | :: | sest | |||
| complex(kind=sp), | intent(in) | :: | w(j) | |||
| complex(kind=sp), | intent(in) | :: | gamma | |||
| real(kind=sp), | intent(out) | :: | sestpr | |||
| complex(kind=sp), | intent(out) | :: | s | |||
| complex(kind=sp), | intent(out) | :: | c |
DLAIC1 applies one step of incremental condition estimation in its simplest version: Let x, twonorm(x) = 1, be an approximate singular vector of an j-by-j lower triangular matrix L, such that twonorm(Lx) = sest Then DLAIC1 computes sestpr, s, c such that the vector [ sx ] xhat = [ c ] is an approximate singular vector of [ L 0 ] Lhat = [ wT gamma ] in the sense that twonorm(Lhat*xhat) = sestpr. Depending on JOB, an estimate for the largest or smallest singular value is computed. Note that [s c]T and sestpr2 is an eigenpair of the system diag(sest*sest, 0) + [alpha gamma] * [ alpha ] [ gamma ] where alpha = xT*w.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | job | |||
| integer(kind=ilp), | intent(in) | :: | j | |||
| real(kind=dp), | intent(in) | :: | x(j) | |||
| real(kind=dp), | intent(in) | :: | sest | |||
| real(kind=dp), | intent(in) | :: | w(j) | |||
| real(kind=dp), | intent(in) | :: | gamma | |||
| real(kind=dp), | intent(out) | :: | sestpr | |||
| real(kind=dp), | intent(out) | :: | s | |||
| real(kind=dp), | intent(out) | :: | c |
SLAIC1 applies one step of incremental condition estimation in its simplest version: Let x, twonorm(x) = 1, be an approximate singular vector of an j-by-j lower triangular matrix L, such that twonorm(Lx) = sest Then SLAIC1 computes sestpr, s, c such that the vector [ sx ] xhat = [ c ] is an approximate singular vector of [ L 0 ] Lhat = [ wT gamma ] in the sense that twonorm(Lhat*xhat) = sestpr. Depending on JOB, an estimate for the largest or smallest singular value is computed. Note that [s c]T and sestpr2 is an eigenpair of the system diag(sest*sest, 0) + [alpha gamma] * [ alpha ] [ gamma ] where alpha = xT*w.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | job | |||
| integer(kind=ilp), | intent(in) | :: | j | |||
| real(kind=sp), | intent(in) | :: | x(j) | |||
| real(kind=sp), | intent(in) | :: | sest | |||
| real(kind=sp), | intent(in) | :: | w(j) | |||
| real(kind=sp), | intent(in) | :: | gamma | |||
| real(kind=sp), | intent(out) | :: | sestpr | |||
| real(kind=sp), | intent(out) | :: | s | |||
| real(kind=sp), | intent(out) | :: | c |
ZLAIC1 applies one step of incremental condition estimation in its simplest version: Let x, twonorm(x) = 1, be an approximate singular vector of an j-by-j lower triangular matrix L, such that twonorm(Lx) = sest Then ZLAIC1 computes sestpr, s, c such that the vector [ sx ] xhat = [ c ] is an approximate singular vector of [ L 0 ] Lhat = [ wH gamma ] in the sense that twonorm(Lhat*xhat) = sestpr. Depending on JOB, an estimate for the largest or smallest singular value is computed. Note that [s c]H and sestpr2 is an eigenpair of the system diag(sest*sest, 0) + [alpha gamma] * [ conjg(alpha) ] [ conjg(gamma) ] where alpha = xH * w.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | job | |||
| integer(kind=ilp), | intent(in) | :: | j | |||
| complex(kind=dp), | intent(in) | :: | x(j) | |||
| real(kind=dp), | intent(in) | :: | sest | |||
| complex(kind=dp), | intent(in) | :: | w(j) | |||
| complex(kind=dp), | intent(in) | :: | gamma | |||
| real(kind=dp), | intent(out) | :: | sestpr | |||
| complex(kind=dp), | intent(out) | :: | s | |||
| complex(kind=dp), | intent(out) | :: | c |
This routine is not for general use. It exists solely to avoid over-optimization in DISNAN. LAISNAN checks for NaNs by comparing its two arguments for inequality. NaN is the only floating-point value where NaN != NaN returns .TRUE. To check for NaNs, pass the same variable as both arguments. A compiler must assume that the two arguments are not the same variable, and the test will not be optimized away. Interprocedural or whole-program optimization may delete this test. The ISNAN functions will be replaced by the correct Fortran 03 intrinsic once the intrinsic is widely available.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| real(kind=dp), | intent(in) | :: | din1 | |||
| real(kind=dp), | intent(in) | :: | din2 |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| real(kind=sp), | intent(in) | :: | sin1 | |||
| real(kind=sp), | intent(in) | :: | sin2 |
This routine is not for general use. It exists solely to avoid over-optimization in DISNAN. DLAISNAN checks for NaNs by comparing its two arguments for inequality. NaN is the only floating-point value where NaN != NaN returns .TRUE. To check for NaNs, pass the same variable as both arguments. A compiler must assume that the two arguments are not the same variable, and the test will not be optimized away. Interprocedural or whole-program optimization may delete this test. The ISNAN functions will be replaced by the correct Fortran 03 intrinsic once the intrinsic is widely available.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| real(kind=dp), | intent(in) | :: | din1 | |||
| real(kind=dp), | intent(in) | :: | din2 |
This routine is not for general use. It exists solely to avoid over-optimization in SISNAN. SLAISNAN checks for NaNs by comparing its two arguments for inequality. NaN is the only floating-point value where NaN != NaN returns .TRUE. To check for NaNs, pass the same variable as both arguments. A compiler must assume that the two arguments are not the same variable, and the test will not be optimized away. Interprocedural or whole-program optimization may delete this test. The ISNAN functions will be replaced by the correct Fortran 03 intrinsic once the intrinsic is widely available.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| real(kind=sp), | intent(in) | :: | sin1 | |||
| real(kind=sp), | intent(in) | :: | sin2 |
LALS0 applies back the multiplying factors of either the left or the right singular vector matrix of a diagonal matrix appended by a row to the right hand side matrix B in solving the least squares problem using the divide-and-conquer SVD approach. For the left singular vector matrix, three types of orthogonal matrices are involved: (1L) Givens rotations: the number of such rotations is GIVPTR; the pairs of columns/rows they were applied to are stored in GIVCOL; and the C- and S-values of these rotations are stored in GIVNUM. (2L) Permutation. The (NL+1)-st row of B is to be moved to the first row, and for J=2:N, PERM(J)-th row of B is to be moved to the J-th row. (3L) The left singular vector matrix of the remaining matrix. For the right singular vector matrix, four types of orthogonal matrices are involved: (1R) The right singular vector matrix of the remaining matrix. (2R) If SQRE = 1, one extra Givens rotation to generate the right null space. (3R) The inverse transformation of (2L). (4R) The inverse transformation of (1L).
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | icompq | |||
| integer(kind=ilp), | intent(in) | :: | nl | |||
| integer(kind=ilp), | intent(in) | :: | nr | |||
| integer(kind=ilp), | intent(in) | :: | sqre | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| complex(kind=sp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| complex(kind=sp), | intent(out) | :: | bx(ldbx,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldbx | |||
| integer(kind=ilp), | intent(in) | :: | perm(*) | |||
| integer(kind=ilp), | intent(in) | :: | givptr | |||
| integer(kind=ilp), | intent(in) | :: | givcol(ldgcol,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldgcol | |||
| real(kind=sp), | intent(in) | :: | givnum(ldgnum,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldgnum | |||
| real(kind=sp), | intent(in) | :: | poles(ldgnum,*) | |||
| real(kind=sp), | intent(in) | :: | difl(*) | |||
| real(kind=sp), | intent(in) | :: | difr(ldgnum,*) | |||
| real(kind=sp), | intent(in) | :: | z(*) | |||
| integer(kind=ilp), | intent(in) | :: | k | |||
| real(kind=sp), | intent(in) | :: | c | |||
| real(kind=sp), | intent(in) | :: | s | |||
| real(kind=sp), | intent(out) | :: | rwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | icompq | |||
| integer(kind=ilp), | intent(in) | :: | nl | |||
| integer(kind=ilp), | intent(in) | :: | nr | |||
| integer(kind=ilp), | intent(in) | :: | sqre | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| real(kind=dp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| real(kind=dp), | intent(out) | :: | bx(ldbx,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldbx | |||
| integer(kind=ilp), | intent(in) | :: | perm(*) | |||
| integer(kind=ilp), | intent(in) | :: | givptr | |||
| integer(kind=ilp), | intent(in) | :: | givcol(ldgcol,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldgcol | |||
| real(kind=dp), | intent(in) | :: | givnum(ldgnum,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldgnum | |||
| real(kind=dp), | intent(in) | :: | poles(ldgnum,*) | |||
| real(kind=dp), | intent(in) | :: | difl(*) | |||
| real(kind=dp), | intent(in) | :: | difr(ldgnum,*) | |||
| real(kind=dp), | intent(in) | :: | z(*) | |||
| integer(kind=ilp), | intent(in) | :: | k | |||
| real(kind=dp), | intent(in) | :: | c | |||
| real(kind=dp), | intent(in) | :: | s | |||
| real(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | icompq | |||
| integer(kind=ilp), | intent(in) | :: | nl | |||
| integer(kind=ilp), | intent(in) | :: | nr | |||
| integer(kind=ilp), | intent(in) | :: | sqre | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| real(kind=sp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| real(kind=sp), | intent(out) | :: | bx(ldbx,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldbx | |||
| integer(kind=ilp), | intent(in) | :: | perm(*) | |||
| integer(kind=ilp), | intent(in) | :: | givptr | |||
| integer(kind=ilp), | intent(in) | :: | givcol(ldgcol,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldgcol | |||
| real(kind=sp), | intent(in) | :: | givnum(ldgnum,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldgnum | |||
| real(kind=sp), | intent(in) | :: | poles(ldgnum,*) | |||
| real(kind=sp), | intent(in) | :: | difl(*) | |||
| real(kind=sp), | intent(in) | :: | difr(ldgnum,*) | |||
| real(kind=sp), | intent(in) | :: | z(*) | |||
| integer(kind=ilp), | intent(in) | :: | k | |||
| real(kind=sp), | intent(in) | :: | c | |||
| real(kind=sp), | intent(in) | :: | s | |||
| real(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | icompq | |||
| integer(kind=ilp), | intent(in) | :: | nl | |||
| integer(kind=ilp), | intent(in) | :: | nr | |||
| integer(kind=ilp), | intent(in) | :: | sqre | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| complex(kind=dp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| complex(kind=dp), | intent(out) | :: | bx(ldbx,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldbx | |||
| integer(kind=ilp), | intent(in) | :: | perm(*) | |||
| integer(kind=ilp), | intent(in) | :: | givptr | |||
| integer(kind=ilp), | intent(in) | :: | givcol(ldgcol,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldgcol | |||
| real(kind=dp), | intent(in) | :: | givnum(ldgnum,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldgnum | |||
| real(kind=dp), | intent(in) | :: | poles(ldgnum,*) | |||
| real(kind=dp), | intent(in) | :: | difl(*) | |||
| real(kind=dp), | intent(in) | :: | difr(ldgnum,*) | |||
| real(kind=dp), | intent(in) | :: | z(*) | |||
| integer(kind=ilp), | intent(in) | :: | k | |||
| real(kind=dp), | intent(in) | :: | c | |||
| real(kind=dp), | intent(in) | :: | s | |||
| real(kind=dp), | intent(out) | :: | rwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
CLALS0 applies back the multiplying factors of either the left or the right singular vector matrix of a diagonal matrix appended by a row to the right hand side matrix B in solving the least squares problem using the divide-and-conquer SVD approach. For the left singular vector matrix, three types of orthogonal matrices are involved: (1L) Givens rotations: the number of such rotations is GIVPTR; the pairs of columns/rows they were applied to are stored in GIVCOL; and the C- and S-values of these rotations are stored in GIVNUM. (2L) Permutation. The (NL+1)-st row of B is to be moved to the first row, and for J=2:N, PERM(J)-th row of B is to be moved to the J-th row. (3L) The left singular vector matrix of the remaining matrix. For the right singular vector matrix, four types of orthogonal matrices are involved: (1R) The right singular vector matrix of the remaining matrix. (2R) If SQRE = 1, one extra Givens rotation to generate the right null space. (3R) The inverse transformation of (2L). (4R) The inverse transformation of (1L).
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | icompq | |||
| integer(kind=ilp), | intent(in) | :: | nl | |||
| integer(kind=ilp), | intent(in) | :: | nr | |||
| integer(kind=ilp), | intent(in) | :: | sqre | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| complex(kind=sp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| complex(kind=sp), | intent(out) | :: | bx(ldbx,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldbx | |||
| integer(kind=ilp), | intent(in) | :: | perm(*) | |||
| integer(kind=ilp), | intent(in) | :: | givptr | |||
| integer(kind=ilp), | intent(in) | :: | givcol(ldgcol,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldgcol | |||
| real(kind=sp), | intent(in) | :: | givnum(ldgnum,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldgnum | |||
| real(kind=sp), | intent(in) | :: | poles(ldgnum,*) | |||
| real(kind=sp), | intent(in) | :: | difl(*) | |||
| real(kind=sp), | intent(in) | :: | difr(ldgnum,*) | |||
| real(kind=sp), | intent(in) | :: | z(*) | |||
| integer(kind=ilp), | intent(in) | :: | k | |||
| real(kind=sp), | intent(in) | :: | c | |||
| real(kind=sp), | intent(in) | :: | s | |||
| real(kind=sp), | intent(out) | :: | rwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
DLALS0 applies back the multiplying factors of either the left or the right singular vector matrix of a diagonal matrix appended by a row to the right hand side matrix B in solving the least squares problem using the divide-and-conquer SVD approach. For the left singular vector matrix, three types of orthogonal matrices are involved: (1L) Givens rotations: the number of such rotations is GIVPTR; the pairs of columns/rows they were applied to are stored in GIVCOL; and the C- and S-values of these rotations are stored in GIVNUM. (2L) Permutation. The (NL+1)-st row of B is to be moved to the first row, and for J=2:N, PERM(J)-th row of B is to be moved to the J-th row. (3L) The left singular vector matrix of the remaining matrix. For the right singular vector matrix, four types of orthogonal matrices are involved: (1R) The right singular vector matrix of the remaining matrix. (2R) If SQRE = 1, one extra Givens rotation to generate the right null space. (3R) The inverse transformation of (2L). (4R) The inverse transformation of (1L).
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | icompq | |||
| integer(kind=ilp), | intent(in) | :: | nl | |||
| integer(kind=ilp), | intent(in) | :: | nr | |||
| integer(kind=ilp), | intent(in) | :: | sqre | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| real(kind=dp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| real(kind=dp), | intent(out) | :: | bx(ldbx,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldbx | |||
| integer(kind=ilp), | intent(in) | :: | perm(*) | |||
| integer(kind=ilp), | intent(in) | :: | givptr | |||
| integer(kind=ilp), | intent(in) | :: | givcol(ldgcol,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldgcol | |||
| real(kind=dp), | intent(in) | :: | givnum(ldgnum,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldgnum | |||
| real(kind=dp), | intent(in) | :: | poles(ldgnum,*) | |||
| real(kind=dp), | intent(in) | :: | difl(*) | |||
| real(kind=dp), | intent(in) | :: | difr(ldgnum,*) | |||
| real(kind=dp), | intent(in) | :: | z(*) | |||
| integer(kind=ilp), | intent(in) | :: | k | |||
| real(kind=dp), | intent(in) | :: | c | |||
| real(kind=dp), | intent(in) | :: | s | |||
| real(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
SLALS0 applies back the multiplying factors of either the left or the right singular vector matrix of a diagonal matrix appended by a row to the right hand side matrix B in solving the least squares problem using the divide-and-conquer SVD approach. For the left singular vector matrix, three types of orthogonal matrices are involved: (1L) Givens rotations: the number of such rotations is GIVPTR; the pairs of columns/rows they were applied to are stored in GIVCOL; and the C- and S-values of these rotations are stored in GIVNUM. (2L) Permutation. The (NL+1)-st row of B is to be moved to the first row, and for J=2:N, PERM(J)-th row of B is to be moved to the J-th row. (3L) The left singular vector matrix of the remaining matrix. For the right singular vector matrix, four types of orthogonal matrices are involved: (1R) The right singular vector matrix of the remaining matrix. (2R) If SQRE = 1, one extra Givens rotation to generate the right null space. (3R) The inverse transformation of (2L). (4R) The inverse transformation of (1L).
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | icompq | |||
| integer(kind=ilp), | intent(in) | :: | nl | |||
| integer(kind=ilp), | intent(in) | :: | nr | |||
| integer(kind=ilp), | intent(in) | :: | sqre | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| real(kind=sp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| real(kind=sp), | intent(out) | :: | bx(ldbx,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldbx | |||
| integer(kind=ilp), | intent(in) | :: | perm(*) | |||
| integer(kind=ilp), | intent(in) | :: | givptr | |||
| integer(kind=ilp), | intent(in) | :: | givcol(ldgcol,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldgcol | |||
| real(kind=sp), | intent(in) | :: | givnum(ldgnum,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldgnum | |||
| real(kind=sp), | intent(in) | :: | poles(ldgnum,*) | |||
| real(kind=sp), | intent(in) | :: | difl(*) | |||
| real(kind=sp), | intent(in) | :: | difr(ldgnum,*) | |||
| real(kind=sp), | intent(in) | :: | z(*) | |||
| integer(kind=ilp), | intent(in) | :: | k | |||
| real(kind=sp), | intent(in) | :: | c | |||
| real(kind=sp), | intent(in) | :: | s | |||
| real(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
ZLALS0 applies back the multiplying factors of either the left or the right singular vector matrix of a diagonal matrix appended by a row to the right hand side matrix B in solving the least squares problem using the divide-and-conquer SVD approach. For the left singular vector matrix, three types of orthogonal matrices are involved: (1L) Givens rotations: the number of such rotations is GIVPTR; the pairs of columns/rows they were applied to are stored in GIVCOL; and the C- and S-values of these rotations are stored in GIVNUM. (2L) Permutation. The (NL+1)-st row of B is to be moved to the first row, and for J=2:N, PERM(J)-th row of B is to be moved to the J-th row. (3L) The left singular vector matrix of the remaining matrix. For the right singular vector matrix, four types of orthogonal matrices are involved: (1R) The right singular vector matrix of the remaining matrix. (2R) If SQRE = 1, one extra Givens rotation to generate the right null space. (3R) The inverse transformation of (2L). (4R) The inverse transformation of (1L).
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | icompq | |||
| integer(kind=ilp), | intent(in) | :: | nl | |||
| integer(kind=ilp), | intent(in) | :: | nr | |||
| integer(kind=ilp), | intent(in) | :: | sqre | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| complex(kind=dp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| complex(kind=dp), | intent(out) | :: | bx(ldbx,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldbx | |||
| integer(kind=ilp), | intent(in) | :: | perm(*) | |||
| integer(kind=ilp), | intent(in) | :: | givptr | |||
| integer(kind=ilp), | intent(in) | :: | givcol(ldgcol,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldgcol | |||
| real(kind=dp), | intent(in) | :: | givnum(ldgnum,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldgnum | |||
| real(kind=dp), | intent(in) | :: | poles(ldgnum,*) | |||
| real(kind=dp), | intent(in) | :: | difl(*) | |||
| real(kind=dp), | intent(in) | :: | difr(ldgnum,*) | |||
| real(kind=dp), | intent(in) | :: | z(*) | |||
| integer(kind=ilp), | intent(in) | :: | k | |||
| real(kind=dp), | intent(in) | :: | c | |||
| real(kind=dp), | intent(in) | :: | s | |||
| real(kind=dp), | intent(out) | :: | rwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
LALSA is an itermediate step in solving the least squares problem by computing the SVD of the coefficient matrix in compact form (The singular vectors are computed as products of simple orthorgonal matrices.). If ICOMPQ = 0, LALSA applies the inverse of the left singular vector matrix of an upper bidiagonal matrix to the right hand side; and if ICOMPQ = 1, LALSA applies the right singular vector matrix to the right hand side. The singular vector matrices were generated in compact form by LALSA.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | icompq | |||
| integer(kind=ilp), | intent(in) | :: | smlsiz | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| complex(kind=sp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| complex(kind=sp), | intent(out) | :: | bx(ldbx,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldbx | |||
| real(kind=sp), | intent(in) | :: | u(ldu,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldu | |||
| real(kind=sp), | intent(in) | :: | vt(ldu,*) | |||
| integer(kind=ilp), | intent(in) | :: | k(*) | |||
| real(kind=sp), | intent(in) | :: | difl(ldu,*) | |||
| real(kind=sp), | intent(in) | :: | difr(ldu,*) | |||
| real(kind=sp), | intent(in) | :: | z(ldu,*) | |||
| real(kind=sp), | intent(in) | :: | poles(ldu,*) | |||
| integer(kind=ilp), | intent(in) | :: | givptr(*) | |||
| integer(kind=ilp), | intent(in) | :: | givcol(ldgcol,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldgcol | |||
| integer(kind=ilp), | intent(in) | :: | perm(ldgcol,*) | |||
| real(kind=sp), | intent(in) | :: | givnum(ldu,*) | |||
| real(kind=sp), | intent(in) | :: | c(*) | |||
| real(kind=sp), | intent(in) | :: | s(*) | |||
| real(kind=sp), | intent(out) | :: | rwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | iwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | icompq | |||
| integer(kind=ilp), | intent(in) | :: | smlsiz | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| real(kind=dp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| real(kind=dp), | intent(out) | :: | bx(ldbx,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldbx | |||
| real(kind=dp), | intent(in) | :: | u(ldu,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldu | |||
| real(kind=dp), | intent(in) | :: | vt(ldu,*) | |||
| integer(kind=ilp), | intent(in) | :: | k(*) | |||
| real(kind=dp), | intent(in) | :: | difl(ldu,*) | |||
| real(kind=dp), | intent(in) | :: | difr(ldu,*) | |||
| real(kind=dp), | intent(in) | :: | z(ldu,*) | |||
| real(kind=dp), | intent(in) | :: | poles(ldu,*) | |||
| integer(kind=ilp), | intent(in) | :: | givptr(*) | |||
| integer(kind=ilp), | intent(in) | :: | givcol(ldgcol,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldgcol | |||
| integer(kind=ilp), | intent(in) | :: | perm(ldgcol,*) | |||
| real(kind=dp), | intent(in) | :: | givnum(ldu,*) | |||
| real(kind=dp), | intent(in) | :: | c(*) | |||
| real(kind=dp), | intent(in) | :: | s(*) | |||
| real(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | iwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | icompq | |||
| integer(kind=ilp), | intent(in) | :: | smlsiz | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| real(kind=sp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| real(kind=sp), | intent(out) | :: | bx(ldbx,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldbx | |||
| real(kind=sp), | intent(in) | :: | u(ldu,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldu | |||
| real(kind=sp), | intent(in) | :: | vt(ldu,*) | |||
| integer(kind=ilp), | intent(in) | :: | k(*) | |||
| real(kind=sp), | intent(in) | :: | difl(ldu,*) | |||
| real(kind=sp), | intent(in) | :: | difr(ldu,*) | |||
| real(kind=sp), | intent(in) | :: | z(ldu,*) | |||
| real(kind=sp), | intent(in) | :: | poles(ldu,*) | |||
| integer(kind=ilp), | intent(in) | :: | givptr(*) | |||
| integer(kind=ilp), | intent(in) | :: | givcol(ldgcol,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldgcol | |||
| integer(kind=ilp), | intent(in) | :: | perm(ldgcol,*) | |||
| real(kind=sp), | intent(in) | :: | givnum(ldu,*) | |||
| real(kind=sp), | intent(in) | :: | c(*) | |||
| real(kind=sp), | intent(in) | :: | s(*) | |||
| real(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | iwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | icompq | |||
| integer(kind=ilp), | intent(in) | :: | smlsiz | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| complex(kind=dp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| complex(kind=dp), | intent(out) | :: | bx(ldbx,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldbx | |||
| real(kind=dp), | intent(in) | :: | u(ldu,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldu | |||
| real(kind=dp), | intent(in) | :: | vt(ldu,*) | |||
| integer(kind=ilp), | intent(in) | :: | k(*) | |||
| real(kind=dp), | intent(in) | :: | difl(ldu,*) | |||
| real(kind=dp), | intent(in) | :: | difr(ldu,*) | |||
| real(kind=dp), | intent(in) | :: | z(ldu,*) | |||
| real(kind=dp), | intent(in) | :: | poles(ldu,*) | |||
| integer(kind=ilp), | intent(in) | :: | givptr(*) | |||
| integer(kind=ilp), | intent(in) | :: | givcol(ldgcol,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldgcol | |||
| integer(kind=ilp), | intent(in) | :: | perm(ldgcol,*) | |||
| real(kind=dp), | intent(in) | :: | givnum(ldu,*) | |||
| real(kind=dp), | intent(in) | :: | c(*) | |||
| real(kind=dp), | intent(in) | :: | s(*) | |||
| real(kind=dp), | intent(out) | :: | rwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | iwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
CLALSA is an itermediate step in solving the least squares problem by computing the SVD of the coefficient matrix in compact form (The singular vectors are computed as products of simple orthorgonal matrices.). If ICOMPQ = 0, CLALSA applies the inverse of the left singular vector matrix of an upper bidiagonal matrix to the right hand side; and if ICOMPQ = 1, CLALSA applies the right singular vector matrix to the right hand side. The singular vector matrices were generated in compact form by CLALSA.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | icompq | |||
| integer(kind=ilp), | intent(in) | :: | smlsiz | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| complex(kind=sp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| complex(kind=sp), | intent(out) | :: | bx(ldbx,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldbx | |||
| real(kind=sp), | intent(in) | :: | u(ldu,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldu | |||
| real(kind=sp), | intent(in) | :: | vt(ldu,*) | |||
| integer(kind=ilp), | intent(in) | :: | k(*) | |||
| real(kind=sp), | intent(in) | :: | difl(ldu,*) | |||
| real(kind=sp), | intent(in) | :: | difr(ldu,*) | |||
| real(kind=sp), | intent(in) | :: | z(ldu,*) | |||
| real(kind=sp), | intent(in) | :: | poles(ldu,*) | |||
| integer(kind=ilp), | intent(in) | :: | givptr(*) | |||
| integer(kind=ilp), | intent(in) | :: | givcol(ldgcol,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldgcol | |||
| integer(kind=ilp), | intent(in) | :: | perm(ldgcol,*) | |||
| real(kind=sp), | intent(in) | :: | givnum(ldu,*) | |||
| real(kind=sp), | intent(in) | :: | c(*) | |||
| real(kind=sp), | intent(in) | :: | s(*) | |||
| real(kind=sp), | intent(out) | :: | rwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | iwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
DLALSA is an itermediate step in solving the least squares problem by computing the SVD of the coefficient matrix in compact form (The singular vectors are computed as products of simple orthorgonal matrices.). If ICOMPQ = 0, DLALSA applies the inverse of the left singular vector matrix of an upper bidiagonal matrix to the right hand side; and if ICOMPQ = 1, DLALSA applies the right singular vector matrix to the right hand side. The singular vector matrices were generated in compact form by DLALSA.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | icompq | |||
| integer(kind=ilp), | intent(in) | :: | smlsiz | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| real(kind=dp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| real(kind=dp), | intent(out) | :: | bx(ldbx,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldbx | |||
| real(kind=dp), | intent(in) | :: | u(ldu,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldu | |||
| real(kind=dp), | intent(in) | :: | vt(ldu,*) | |||
| integer(kind=ilp), | intent(in) | :: | k(*) | |||
| real(kind=dp), | intent(in) | :: | difl(ldu,*) | |||
| real(kind=dp), | intent(in) | :: | difr(ldu,*) | |||
| real(kind=dp), | intent(in) | :: | z(ldu,*) | |||
| real(kind=dp), | intent(in) | :: | poles(ldu,*) | |||
| integer(kind=ilp), | intent(in) | :: | givptr(*) | |||
| integer(kind=ilp), | intent(in) | :: | givcol(ldgcol,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldgcol | |||
| integer(kind=ilp), | intent(in) | :: | perm(ldgcol,*) | |||
| real(kind=dp), | intent(in) | :: | givnum(ldu,*) | |||
| real(kind=dp), | intent(in) | :: | c(*) | |||
| real(kind=dp), | intent(in) | :: | s(*) | |||
| real(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | iwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
SLALSA is an itermediate step in solving the least squares problem by computing the SVD of the coefficient matrix in compact form (The singular vectors are computed as products of simple orthorgonal matrices.). If ICOMPQ = 0, SLALSA applies the inverse of the left singular vector matrix of an upper bidiagonal matrix to the right hand side; and if ICOMPQ = 1, SLALSA applies the right singular vector matrix to the right hand side. The singular vector matrices were generated in compact form by SLALSA.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | icompq | |||
| integer(kind=ilp), | intent(in) | :: | smlsiz | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| real(kind=sp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| real(kind=sp), | intent(out) | :: | bx(ldbx,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldbx | |||
| real(kind=sp), | intent(in) | :: | u(ldu,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldu | |||
| real(kind=sp), | intent(in) | :: | vt(ldu,*) | |||
| integer(kind=ilp), | intent(in) | :: | k(*) | |||
| real(kind=sp), | intent(in) | :: | difl(ldu,*) | |||
| real(kind=sp), | intent(in) | :: | difr(ldu,*) | |||
| real(kind=sp), | intent(in) | :: | z(ldu,*) | |||
| real(kind=sp), | intent(in) | :: | poles(ldu,*) | |||
| integer(kind=ilp), | intent(in) | :: | givptr(*) | |||
| integer(kind=ilp), | intent(in) | :: | givcol(ldgcol,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldgcol | |||
| integer(kind=ilp), | intent(in) | :: | perm(ldgcol,*) | |||
| real(kind=sp), | intent(in) | :: | givnum(ldu,*) | |||
| real(kind=sp), | intent(in) | :: | c(*) | |||
| real(kind=sp), | intent(in) | :: | s(*) | |||
| real(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | iwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
ZLALSA is an itermediate step in solving the least squares problem by computing the SVD of the coefficient matrix in compact form (The singular vectors are computed as products of simple orthorgonal matrices.). If ICOMPQ = 0, ZLALSA applies the inverse of the left singular vector matrix of an upper bidiagonal matrix to the right hand side; and if ICOMPQ = 1, ZLALSA applies the right singular vector matrix to the right hand side. The singular vector matrices were generated in compact form by ZLALSA.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | icompq | |||
| integer(kind=ilp), | intent(in) | :: | smlsiz | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| complex(kind=dp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| complex(kind=dp), | intent(out) | :: | bx(ldbx,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldbx | |||
| real(kind=dp), | intent(in) | :: | u(ldu,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldu | |||
| real(kind=dp), | intent(in) | :: | vt(ldu,*) | |||
| integer(kind=ilp), | intent(in) | :: | k(*) | |||
| real(kind=dp), | intent(in) | :: | difl(ldu,*) | |||
| real(kind=dp), | intent(in) | :: | difr(ldu,*) | |||
| real(kind=dp), | intent(in) | :: | z(ldu,*) | |||
| real(kind=dp), | intent(in) | :: | poles(ldu,*) | |||
| integer(kind=ilp), | intent(in) | :: | givptr(*) | |||
| integer(kind=ilp), | intent(in) | :: | givcol(ldgcol,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldgcol | |||
| integer(kind=ilp), | intent(in) | :: | perm(ldgcol,*) | |||
| real(kind=dp), | intent(in) | :: | givnum(ldu,*) | |||
| real(kind=dp), | intent(in) | :: | c(*) | |||
| real(kind=dp), | intent(in) | :: | s(*) | |||
| real(kind=dp), | intent(out) | :: | rwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | iwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
LALSD uses the singular value decomposition of A to solve the least squares problem of finding X to minimize the Euclidean norm of each column of A*X-B, where A is N-by-N upper bidiagonal, and X and B are N-by-NRHS. The solution X overwrites B. The singular values of A smaller than RCOND times the largest singular value are treated as zero in solving the least squares problem; in this case a minimum norm solution is returned. The actual singular values are returned in D in ascending order. This code makes very mild assumptions about floating point arithmetic. It will work on machines with a guard digit in add/subtract, or on those binary machines without guard digits which subtract like the Cray XMP, Cray YMP, Cray C 90, or Cray 2. It could conceivably fail on hexadecimal or decimal machines without guard digits, but we know of none.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | smlsiz | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| real(kind=sp), | intent(inout) | :: | d(*) | |||
| real(kind=sp), | intent(inout) | :: | e(*) | |||
| complex(kind=sp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| real(kind=sp), | intent(in) | :: | rcond | |||
| integer(kind=ilp), | intent(out) | :: | rank | |||
| complex(kind=sp), | intent(out) | :: | work(*) | |||
| real(kind=sp), | intent(out) | :: | rwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | iwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | smlsiz | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| real(kind=dp), | intent(inout) | :: | d(*) | |||
| real(kind=dp), | intent(inout) | :: | e(*) | |||
| real(kind=dp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| real(kind=dp), | intent(in) | :: | rcond | |||
| integer(kind=ilp), | intent(out) | :: | rank | |||
| real(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | iwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | smlsiz | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| real(kind=sp), | intent(inout) | :: | d(*) | |||
| real(kind=sp), | intent(inout) | :: | e(*) | |||
| real(kind=sp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| real(kind=sp), | intent(in) | :: | rcond | |||
| integer(kind=ilp), | intent(out) | :: | rank | |||
| real(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | iwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | smlsiz | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| real(kind=dp), | intent(inout) | :: | d(*) | |||
| real(kind=dp), | intent(inout) | :: | e(*) | |||
| complex(kind=dp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| real(kind=dp), | intent(in) | :: | rcond | |||
| integer(kind=ilp), | intent(out) | :: | rank | |||
| complex(kind=dp), | intent(out) | :: | work(*) | |||
| real(kind=dp), | intent(out) | :: | rwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | iwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
CLALSD uses the singular value decomposition of A to solve the least squares problem of finding X to minimize the Euclidean norm of each column of A*X-B, where A is N-by-N upper bidiagonal, and X and B are N-by-NRHS. The solution X overwrites B. The singular values of A smaller than RCOND times the largest singular value are treated as zero in solving the least squares problem; in this case a minimum norm solution is returned. The actual singular values are returned in D in ascending order. This code makes very mild assumptions about floating point arithmetic. It will work on machines with a guard digit in add/subtract, or on those binary machines without guard digits which subtract like the Cray XMP, Cray YMP, Cray C 90, or Cray 2. It could conceivably fail on hexadecimal or decimal machines without guard digits, but we know of none.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | smlsiz | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| real(kind=sp), | intent(inout) | :: | d(*) | |||
| real(kind=sp), | intent(inout) | :: | e(*) | |||
| complex(kind=sp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| real(kind=sp), | intent(in) | :: | rcond | |||
| integer(kind=ilp), | intent(out) | :: | rank | |||
| complex(kind=sp), | intent(out) | :: | work(*) | |||
| real(kind=sp), | intent(out) | :: | rwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | iwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
DLALSD uses the singular value decomposition of A to solve the least squares problem of finding X to minimize the Euclidean norm of each column of A*X-B, where A is N-by-N upper bidiagonal, and X and B are N-by-NRHS. The solution X overwrites B. The singular values of A smaller than RCOND times the largest singular value are treated as zero in solving the least squares problem; in this case a minimum norm solution is returned. The actual singular values are returned in D in ascending order. This code makes very mild assumptions about floating point arithmetic. It will work on machines with a guard digit in add/subtract, or on those binary machines without guard digits which subtract like the Cray XMP, Cray YMP, Cray C 90, or Cray 2. It could conceivably fail on hexadecimal or decimal machines without guard digits, but we know of none.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | smlsiz | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| real(kind=dp), | intent(inout) | :: | d(*) | |||
| real(kind=dp), | intent(inout) | :: | e(*) | |||
| real(kind=dp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| real(kind=dp), | intent(in) | :: | rcond | |||
| integer(kind=ilp), | intent(out) | :: | rank | |||
| real(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | iwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
SLALSD uses the singular value decomposition of A to solve the least squares problem of finding X to minimize the Euclidean norm of each column of A*X-B, where A is N-by-N upper bidiagonal, and X and B are N-by-NRHS. The solution X overwrites B. The singular values of A smaller than RCOND times the largest singular value are treated as zero in solving the least squares problem; in this case a minimum norm solution is returned. The actual singular values are returned in D in ascending order. This code makes very mild assumptions about floating point arithmetic. It will work on machines with a guard digit in add/subtract, or on those binary machines without guard digits which subtract like the Cray XMP, Cray YMP, Cray C 90, or Cray 2. It could conceivably fail on hexadecimal or decimal machines without guard digits, but we know of none.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | smlsiz | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| real(kind=sp), | intent(inout) | :: | d(*) | |||
| real(kind=sp), | intent(inout) | :: | e(*) | |||
| real(kind=sp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| real(kind=sp), | intent(in) | :: | rcond | |||
| integer(kind=ilp), | intent(out) | :: | rank | |||
| real(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | iwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
ZLALSD uses the singular value decomposition of A to solve the least squares problem of finding X to minimize the Euclidean norm of each column of A*X-B, where A is N-by-N upper bidiagonal, and X and B are N-by-NRHS. The solution X overwrites B. The singular values of A smaller than RCOND times the largest singular value are treated as zero in solving the least squares problem; in this case a minimum norm solution is returned. The actual singular values are returned in D in ascending order. This code makes very mild assumptions about floating point arithmetic. It will work on machines with a guard digit in add/subtract, or on those binary machines without guard digits which subtract like the Cray XMP, Cray YMP, Cray C 90, or Cray 2. It could conceivably fail on hexadecimal or decimal machines without guard digits, but we know of none.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | smlsiz | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| real(kind=dp), | intent(inout) | :: | d(*) | |||
| real(kind=dp), | intent(inout) | :: | e(*) | |||
| complex(kind=dp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| real(kind=dp), | intent(in) | :: | rcond | |||
| integer(kind=ilp), | intent(out) | :: | rank | |||
| complex(kind=dp), | intent(out) | :: | work(*) | |||
| real(kind=dp), | intent(out) | :: | rwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | iwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
LAMRG will create a permutation list which will merge the elements of A (which is composed of two independently sorted sets) into a single set which is sorted in ascending order.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | n1 | |||
| integer(kind=ilp), | intent(in) | :: | n2 | |||
| real(kind=dp), | intent(in) | :: | a(*) | |||
| integer(kind=ilp), | intent(in) | :: | dtrd1 | |||
| integer(kind=ilp), | intent(in) | :: | dtrd2 | |||
| integer(kind=ilp), | intent(out) | :: | index(*) |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | n1 | |||
| integer(kind=ilp), | intent(in) | :: | n2 | |||
| real(kind=sp), | intent(in) | :: | a(*) | |||
| integer(kind=ilp), | intent(in) | :: | strd1 | |||
| integer(kind=ilp), | intent(in) | :: | strd2 | |||
| integer(kind=ilp), | intent(out) | :: | index(*) |
DLAMRG will create a permutation list which will merge the elements of A (which is composed of two independently sorted sets) into a single set which is sorted in ascending order.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | n1 | |||
| integer(kind=ilp), | intent(in) | :: | n2 | |||
| real(kind=dp), | intent(in) | :: | a(*) | |||
| integer(kind=ilp), | intent(in) | :: | dtrd1 | |||
| integer(kind=ilp), | intent(in) | :: | dtrd2 | |||
| integer(kind=ilp), | intent(out) | :: | index(*) |
SLAMRG will create a permutation list which will merge the elements of A (which is composed of two independently sorted sets) into a single set which is sorted in ascending order.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | n1 | |||
| integer(kind=ilp), | intent(in) | :: | n2 | |||
| real(kind=sp), | intent(in) | :: | a(*) | |||
| integer(kind=ilp), | intent(in) | :: | strd1 | |||
| integer(kind=ilp), | intent(in) | :: | strd2 | |||
| integer(kind=ilp), | intent(out) | :: | index(*) |
LAMSWLQ overwrites the general complex M-by-N matrix C with SIDE = 'L' SIDE = 'R' TRANS = 'N': Q * C C * Q TRANS = 'T': QH * C C * QH where Q is a complex unitary matrix defined as the product of blocked elementary reflectors computed by short wide LQ factorization (CLASWLQ)
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | side | |||
| character, | intent(in) | :: | trans | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | k | |||
| integer(kind=ilp), | intent(in) | :: | mb | |||
| integer(kind=ilp), | intent(in) | :: | nb | |||
| complex(kind=sp), | intent(in) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=sp), | intent(in) | :: | t(ldt,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldt | |||
| complex(kind=sp), | intent(inout) | :: | c(ldc,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldc | |||
| complex(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | side | |||
| character, | intent(in) | :: | trans | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | k | |||
| integer(kind=ilp), | intent(in) | :: | mb | |||
| integer(kind=ilp), | intent(in) | :: | nb | |||
| real(kind=dp), | intent(in) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=dp), | intent(in) | :: | t(ldt,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldt | |||
| real(kind=dp), | intent(inout) | :: | c(ldc,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldc | |||
| real(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | side | |||
| character, | intent(in) | :: | trans | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | k | |||
| integer(kind=ilp), | intent(in) | :: | mb | |||
| integer(kind=ilp), | intent(in) | :: | nb | |||
| real(kind=sp), | intent(in) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=sp), | intent(in) | :: | t(ldt,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldt | |||
| real(kind=sp), | intent(inout) | :: | c(ldc,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldc | |||
| real(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | side | |||
| character, | intent(in) | :: | trans | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | k | |||
| integer(kind=ilp), | intent(in) | :: | mb | |||
| integer(kind=ilp), | intent(in) | :: | nb | |||
| complex(kind=dp), | intent(in) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=dp), | intent(in) | :: | t(ldt,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldt | |||
| complex(kind=dp), | intent(inout) | :: | c(ldc,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldc | |||
| complex(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
CLAMSWLQ overwrites the general complex M-by-N matrix C with SIDE = 'L' SIDE = 'R' TRANS = 'N': Q * C C * Q TRANS = 'T': QH * C C * QH where Q is a complex unitary matrix defined as the product of blocked elementary reflectors computed by short wide LQ factorization (CLASWLQ)
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | side | |||
| character, | intent(in) | :: | trans | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | k | |||
| integer(kind=ilp), | intent(in) | :: | mb | |||
| integer(kind=ilp), | intent(in) | :: | nb | |||
| complex(kind=sp), | intent(in) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=sp), | intent(in) | :: | t(ldt,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldt | |||
| complex(kind=sp), | intent(inout) | :: | c(ldc,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldc | |||
| complex(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
DLAMSWLQ overwrites the general real M-by-N matrix C with SIDE = 'L' SIDE = 'R' TRANS = 'N': Q * C C * Q TRANS = 'T': QT * C C * QT where Q is a real orthogonal matrix defined as the product of blocked elementary reflectors computed by short wide LQ factorization (DLASWLQ)
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | side | |||
| character, | intent(in) | :: | trans | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | k | |||
| integer(kind=ilp), | intent(in) | :: | mb | |||
| integer(kind=ilp), | intent(in) | :: | nb | |||
| real(kind=dp), | intent(in) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=dp), | intent(in) | :: | t(ldt,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldt | |||
| real(kind=dp), | intent(inout) | :: | c(ldc,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldc | |||
| real(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
SLAMSWLQ overwrites the general real M-by-N matrix C with SIDE = 'L' SIDE = 'R' TRANS = 'N': Q * C C * Q TRANS = 'T': QT * C C * QT where Q is a real orthogonal matrix defined as the product of blocked elementary reflectors computed by short wide LQ factorization (SLASWLQ)
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | side | |||
| character, | intent(in) | :: | trans | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | k | |||
| integer(kind=ilp), | intent(in) | :: | mb | |||
| integer(kind=ilp), | intent(in) | :: | nb | |||
| real(kind=sp), | intent(in) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=sp), | intent(in) | :: | t(ldt,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldt | |||
| real(kind=sp), | intent(inout) | :: | c(ldc,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldc | |||
| real(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
ZLAMSWLQ overwrites the general complex M-by-N matrix C with SIDE = 'L' SIDE = 'R' TRANS = 'N': Q * C C * Q TRANS = 'C': QH * C C * QH where Q is a complex unitary matrix defined as the product of blocked elementary reflectors computed by short wide LQ factorization (ZLASWLQ)
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | side | |||
| character, | intent(in) | :: | trans | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | k | |||
| integer(kind=ilp), | intent(in) | :: | mb | |||
| integer(kind=ilp), | intent(in) | :: | nb | |||
| complex(kind=dp), | intent(in) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=dp), | intent(in) | :: | t(ldt,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldt | |||
| complex(kind=dp), | intent(inout) | :: | c(ldc,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldc | |||
| complex(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
LAMTSQR overwrites the general complex M-by-N matrix C with SIDE = 'L' SIDE = 'R' TRANS = 'N': Q * C C * Q TRANS = 'C': QH * C C * QH where Q is a complex unitary matrix defined as the product of blocked elementary reflectors computed by tall skinny QR factorization (CLATSQR)
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | side | |||
| character, | intent(in) | :: | trans | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | k | |||
| integer(kind=ilp), | intent(in) | :: | mb | |||
| integer(kind=ilp), | intent(in) | :: | nb | |||
| complex(kind=sp), | intent(in) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=sp), | intent(in) | :: | t(ldt,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldt | |||
| complex(kind=sp), | intent(inout) | :: | c(ldc,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldc | |||
| complex(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | side | |||
| character, | intent(in) | :: | trans | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | k | |||
| integer(kind=ilp), | intent(in) | :: | mb | |||
| integer(kind=ilp), | intent(in) | :: | nb | |||
| real(kind=dp), | intent(in) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=dp), | intent(in) | :: | t(ldt,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldt | |||
| real(kind=dp), | intent(inout) | :: | c(ldc,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldc | |||
| real(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | side | |||
| character, | intent(in) | :: | trans | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | k | |||
| integer(kind=ilp), | intent(in) | :: | mb | |||
| integer(kind=ilp), | intent(in) | :: | nb | |||
| real(kind=sp), | intent(in) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=sp), | intent(in) | :: | t(ldt,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldt | |||
| real(kind=sp), | intent(inout) | :: | c(ldc,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldc | |||
| real(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | side | |||
| character, | intent(in) | :: | trans | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | k | |||
| integer(kind=ilp), | intent(in) | :: | mb | |||
| integer(kind=ilp), | intent(in) | :: | nb | |||
| complex(kind=dp), | intent(in) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=dp), | intent(in) | :: | t(ldt,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldt | |||
| complex(kind=dp), | intent(inout) | :: | c(ldc,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldc | |||
| complex(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
CLAMTSQR overwrites the general complex M-by-N matrix C with SIDE = 'L' SIDE = 'R' TRANS = 'N': Q * C C * Q TRANS = 'C': QH * C C * QH where Q is a complex unitary matrix defined as the product of blocked elementary reflectors computed by tall skinny QR factorization (CLATSQR)
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | side | |||
| character, | intent(in) | :: | trans | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | k | |||
| integer(kind=ilp), | intent(in) | :: | mb | |||
| integer(kind=ilp), | intent(in) | :: | nb | |||
| complex(kind=sp), | intent(in) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=sp), | intent(in) | :: | t(ldt,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldt | |||
| complex(kind=sp), | intent(inout) | :: | c(ldc,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldc | |||
| complex(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
DLAMTSQR overwrites the general real M-by-N matrix C with SIDE = 'L' SIDE = 'R' TRANS = 'N': Q * C C * Q TRANS = 'T': QT * C C * QT where Q is a real orthogonal matrix defined as the product of blocked elementary reflectors computed by tall skinny QR factorization (DLATSQR)
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | side | |||
| character, | intent(in) | :: | trans | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | k | |||
| integer(kind=ilp), | intent(in) | :: | mb | |||
| integer(kind=ilp), | intent(in) | :: | nb | |||
| real(kind=dp), | intent(in) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=dp), | intent(in) | :: | t(ldt,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldt | |||
| real(kind=dp), | intent(inout) | :: | c(ldc,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldc | |||
| real(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
SLAMTSQR overwrites the general real M-by-N matrix C with SIDE = 'L' SIDE = 'R' TRANS = 'N': Q * C C * Q TRANS = 'T': QT * C C * QT where Q is a real orthogonal matrix defined as the product of blocked elementary reflectors computed by tall skinny QR factorization (SLATSQR)
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | side | |||
| character, | intent(in) | :: | trans | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | k | |||
| integer(kind=ilp), | intent(in) | :: | mb | |||
| integer(kind=ilp), | intent(in) | :: | nb | |||
| real(kind=sp), | intent(in) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=sp), | intent(in) | :: | t(ldt,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldt | |||
| real(kind=sp), | intent(inout) | :: | c(ldc,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldc | |||
| real(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
ZLAMTSQR overwrites the general complex M-by-N matrix C with SIDE = 'L' SIDE = 'R' TRANS = 'N': Q * C C * Q TRANS = 'C': QH * C C * QH where Q is a complex unitary matrix defined as the product of blocked elementary reflectors computed by tall skinny QR factorization (ZLATSQR)
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | side | |||
| character, | intent(in) | :: | trans | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | k | |||
| integer(kind=ilp), | intent(in) | :: | mb | |||
| integer(kind=ilp), | intent(in) | :: | nb | |||
| complex(kind=dp), | intent(in) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=dp), | intent(in) | :: | t(ldt,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldt | |||
| complex(kind=dp), | intent(inout) | :: | c(ldc,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldc | |||
| complex(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
LANEG computes the Sturm count, the number of negative pivots encountered while factoring tridiagonal T - sigma I = L D L^T. This implementation works directly on the factors without forming the tridiagonal matrix T. The Sturm count is also the number of eigenvalues of T less than sigma. This routine is called from DLARRB. The current routine does not use the PIVMIN parameter but rather requires IEEE-754 propagation of Infinities and NaNs. This routine also has no input range restrictions but does require default exception handling such that x/0 produces Inf when x is non-zero, and Inf/Inf produces NaN. For more information, see: Marques, Riedy, and Voemel, "Benefits of IEEE-754 Features in Modern Symmetric Tridiagonal Eigensolvers," SIAM Journal on Scientific Computing, v28, n5, 2006. DOI 10.1137/050641624 (Tech report version in LAWN 172 with the same title.)
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=dp), | intent(in) | :: | d(*) | |||
| real(kind=dp), | intent(in) | :: | lld(*) | |||
| real(kind=dp), | intent(in) | :: | sigma | |||
| real(kind=dp), | intent(in) | :: | pivmin | |||
| integer(kind=ilp), | intent(in) | :: | r |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=sp), | intent(in) | :: | d(*) | |||
| real(kind=sp), | intent(in) | :: | lld(*) | |||
| real(kind=sp), | intent(in) | :: | sigma | |||
| real(kind=sp), | intent(in) | :: | pivmin | |||
| integer(kind=ilp), | intent(in) | :: | r |
DLANEG computes the Sturm count, the number of negative pivots encountered while factoring tridiagonal T - sigma I = L D L^T. This implementation works directly on the factors without forming the tridiagonal matrix T. The Sturm count is also the number of eigenvalues of T less than sigma. This routine is called from DLARRB. The current routine does not use the PIVMIN parameter but rather requires IEEE-754 propagation of Infinities and NaNs. This routine also has no input range restrictions but does require default exception handling such that x/0 produces Inf when x is non-zero, and Inf/Inf produces NaN. For more information, see: Marques, Riedy, and Voemel, "Benefits of IEEE-754 Features in Modern Symmetric Tridiagonal Eigensolvers," SIAM Journal on Scientific Computing, v28, n5, 2006. DOI 10.1137/050641624 (Tech report version in LAWN 172 with the same title.)
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=dp), | intent(in) | :: | d(*) | |||
| real(kind=dp), | intent(in) | :: | lld(*) | |||
| real(kind=dp), | intent(in) | :: | sigma | |||
| real(kind=dp), | intent(in) | :: | pivmin | |||
| integer(kind=ilp), | intent(in) | :: | r |
SLANEG computes the Sturm count, the number of negative pivots encountered while factoring tridiagonal T - sigma I = L D L^T. This implementation works directly on the factors without forming the tridiagonal matrix T. The Sturm count is also the number of eigenvalues of T less than sigma. This routine is called from SLARRB. The current routine does not use the PIVMIN parameter but rather requires IEEE-754 propagation of Infinities and NaNs. This routine also has no input range restrictions but does require default exception handling such that x/0 produces Inf when x is non-zero, and Inf/Inf produces NaN. For more information, see: Marques, Riedy, and Voemel, "Benefits of IEEE-754 Features in Modern Symmetric Tridiagonal Eigensolvers," SIAM Journal on Scientific Computing, v28, n5, 2006. DOI 10.1137/050641624 (Tech report version in LAWN 172 with the same title.)
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=sp), | intent(in) | :: | d(*) | |||
| real(kind=sp), | intent(in) | :: | lld(*) | |||
| real(kind=sp), | intent(in) | :: | sigma | |||
| real(kind=sp), | intent(in) | :: | pivmin | |||
| integer(kind=ilp), | intent(in) | :: | r |
LANGB returns the value of the one norm, or the Frobenius norm, or the infinity norm, or the element of largest absolute value of an n by n band matrix A, with kl sub-diagonals and ku super-diagonals.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | norm | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | kl | |||
| integer(kind=ilp), | intent(in) | :: | ku | |||
| complex(kind=sp), | intent(in) | :: | ab(ldab,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldab | |||
| real(kind=sp), | intent(out) | :: | work(*) |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | norm | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | kl | |||
| integer(kind=ilp), | intent(in) | :: | ku | |||
| real(kind=dp), | intent(in) | :: | ab(ldab,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldab | |||
| real(kind=dp), | intent(out) | :: | work(*) |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | norm | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | kl | |||
| integer(kind=ilp), | intent(in) | :: | ku | |||
| real(kind=sp), | intent(in) | :: | ab(ldab,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldab | |||
| real(kind=sp), | intent(out) | :: | work(*) |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | norm | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | kl | |||
| integer(kind=ilp), | intent(in) | :: | ku | |||
| complex(kind=dp), | intent(in) | :: | ab(ldab,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldab | |||
| real(kind=dp), | intent(out) | :: | work(*) |
CLANGB returns the value of the one norm, or the Frobenius norm, or the infinity norm, or the element of largest absolute value of an n by n band matrix A, with kl sub-diagonals and ku super-diagonals.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | norm | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | kl | |||
| integer(kind=ilp), | intent(in) | :: | ku | |||
| complex(kind=sp), | intent(in) | :: | ab(ldab,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldab | |||
| real(kind=sp), | intent(out) | :: | work(*) |
DLANGB returns the value of the one norm, or the Frobenius norm, or the infinity norm, or the element of largest absolute value of an n by n band matrix A, with kl sub-diagonals and ku super-diagonals.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | norm | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | kl | |||
| integer(kind=ilp), | intent(in) | :: | ku | |||
| real(kind=dp), | intent(in) | :: | ab(ldab,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldab | |||
| real(kind=dp), | intent(out) | :: | work(*) |
SLANGB returns the value of the one norm, or the Frobenius norm, or the infinity norm, or the element of largest absolute value of an n by n band matrix A, with kl sub-diagonals and ku super-diagonals.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | norm | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | kl | |||
| integer(kind=ilp), | intent(in) | :: | ku | |||
| real(kind=sp), | intent(in) | :: | ab(ldab,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldab | |||
| real(kind=sp), | intent(out) | :: | work(*) |
ZLANGB returns the value of the one norm, or the Frobenius norm, or the infinity norm, or the element of largest absolute value of an n by n band matrix A, with kl sub-diagonals and ku super-diagonals.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | norm | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | kl | |||
| integer(kind=ilp), | intent(in) | :: | ku | |||
| complex(kind=dp), | intent(in) | :: | ab(ldab,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldab | |||
| real(kind=dp), | intent(out) | :: | work(*) |
LANGE returns the value of the one norm, or the Frobenius norm, or the infinity norm, or the element of largest absolute value of a complex matrix A.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | norm | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=sp), | intent(in) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=sp), | intent(out) | :: | work(*) |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | norm | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=dp), | intent(in) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=dp), | intent(out) | :: | work(*) |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | norm | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=sp), | intent(in) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=sp), | intent(out) | :: | work(*) |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | norm | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=dp), | intent(in) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=dp), | intent(out) | :: | work(*) |
CLANGE returns the value of the one norm, or the Frobenius norm, or the infinity norm, or the element of largest absolute value of a complex matrix A.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | norm | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=sp), | intent(in) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=sp), | intent(out) | :: | work(*) |
DLANGE returns the value of the one norm, or the Frobenius norm, or the infinity norm, or the element of largest absolute value of a real matrix A.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | norm | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=dp), | intent(in) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=dp), | intent(out) | :: | work(*) |
SLANGE returns the value of the one norm, or the Frobenius norm, or the infinity norm, or the element of largest absolute value of a real matrix A.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | norm | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=sp), | intent(in) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=sp), | intent(out) | :: | work(*) |
ZLANGE returns the value of the one norm, or the Frobenius norm, or the infinity norm, or the element of largest absolute value of a complex matrix A.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | norm | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=dp), | intent(in) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=dp), | intent(out) | :: | work(*) |
LANGT returns the value of the one norm, or the Frobenius norm, or the infinity norm, or the element of largest absolute value of a complex tridiagonal matrix A.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | norm | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=sp), | intent(in) | :: | dl(*) | |||
| complex(kind=sp), | intent(in) | :: | d(*) | |||
| complex(kind=sp), | intent(in) | :: | du(*) |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | norm | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=dp), | intent(in) | :: | dl(*) | |||
| real(kind=dp), | intent(in) | :: | d(*) | |||
| real(kind=dp), | intent(in) | :: | du(*) |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | norm | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=sp), | intent(in) | :: | dl(*) | |||
| real(kind=sp), | intent(in) | :: | d(*) | |||
| real(kind=sp), | intent(in) | :: | du(*) |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | norm | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=dp), | intent(in) | :: | dl(*) | |||
| complex(kind=dp), | intent(in) | :: | d(*) | |||
| complex(kind=dp), | intent(in) | :: | du(*) |
CLANGT returns the value of the one norm, or the Frobenius norm, or the infinity norm, or the element of largest absolute value of a complex tridiagonal matrix A.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | norm | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=sp), | intent(in) | :: | dl(*) | |||
| complex(kind=sp), | intent(in) | :: | d(*) | |||
| complex(kind=sp), | intent(in) | :: | du(*) |
DLANGT returns the value of the one norm, or the Frobenius norm, or the infinity norm, or the element of largest absolute value of a real tridiagonal matrix A.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | norm | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=dp), | intent(in) | :: | dl(*) | |||
| real(kind=dp), | intent(in) | :: | d(*) | |||
| real(kind=dp), | intent(in) | :: | du(*) |
SLANGT returns the value of the one norm, or the Frobenius norm, or the infinity norm, or the element of largest absolute value of a real tridiagonal matrix A.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | norm | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=sp), | intent(in) | :: | dl(*) | |||
| real(kind=sp), | intent(in) | :: | d(*) | |||
| real(kind=sp), | intent(in) | :: | du(*) |
ZLANGT returns the value of the one norm, or the Frobenius norm, or the infinity norm, or the element of largest absolute value of a complex tridiagonal matrix A.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | norm | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=dp), | intent(in) | :: | dl(*) | |||
| complex(kind=dp), | intent(in) | :: | d(*) | |||
| complex(kind=dp), | intent(in) | :: | du(*) |
LANHB returns the value of the one norm, or the Frobenius norm, or the infinity norm, or the element of largest absolute value of an n by n hermitian band matrix A, with k super-diagonals.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | norm | |||
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | k | |||
| complex(kind=sp), | intent(in) | :: | ab(ldab,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldab | |||
| real(kind=sp), | intent(out) | :: | work(*) |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | norm | |||
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | k | |||
| complex(kind=dp), | intent(in) | :: | ab(ldab,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldab | |||
| real(kind=dp), | intent(out) | :: | work(*) |
CLANHB returns the value of the one norm, or the Frobenius norm, or the infinity norm, or the element of largest absolute value of an n by n hermitian band matrix A, with k super-diagonals.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | norm | |||
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | k | |||
| complex(kind=sp), | intent(in) | :: | ab(ldab,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldab | |||
| real(kind=sp), | intent(out) | :: | work(*) |
ZLANHB returns the value of the one norm, or the Frobenius norm, or the infinity norm, or the element of largest absolute value of an n by n hermitian band matrix A, with k super-diagonals.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | norm | |||
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | k | |||
| complex(kind=dp), | intent(in) | :: | ab(ldab,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldab | |||
| real(kind=dp), | intent(out) | :: | work(*) |
LANHE returns the value of the one norm, or the Frobenius norm, or the infinity norm, or the element of largest absolute value of a complex hermitian matrix A.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | norm | |||
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=sp), | intent(in) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=sp), | intent(out) | :: | work(*) |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | norm | |||
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=dp), | intent(in) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=dp), | intent(out) | :: | work(*) |
CLANHE returns the value of the one norm, or the Frobenius norm, or the infinity norm, or the element of largest absolute value of a complex hermitian matrix A.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | norm | |||
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=sp), | intent(in) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=sp), | intent(out) | :: | work(*) |
ZLANHE returns the value of the one norm, or the Frobenius norm, or the infinity norm, or the element of largest absolute value of a complex hermitian matrix A.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | norm | |||
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=dp), | intent(in) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=dp), | intent(out) | :: | work(*) |
LANHF returns the value of the one norm, or the Frobenius norm, or the infinity norm, or the element of largest absolute value of a complex Hermitian matrix A in RFP format.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | norm | |||
| character, | intent(in) | :: | transr | |||
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=sp), | intent(in) | :: | a(0:*) | |||
| real(kind=sp), | intent(out) | :: | work(0:*) |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | norm | |||
| character, | intent(in) | :: | transr | |||
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=dp), | intent(in) | :: | a(0:*) | |||
| real(kind=dp), | intent(out) | :: | work(0:*) |
CLANHF returns the value of the one norm, or the Frobenius norm, or the infinity norm, or the element of largest absolute value of a complex Hermitian matrix A in RFP format.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | norm | |||
| character, | intent(in) | :: | transr | |||
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=sp), | intent(in) | :: | a(0:*) | |||
| real(kind=sp), | intent(out) | :: | work(0:*) |
ZLANHF returns the value of the one norm, or the Frobenius norm, or the infinity norm, or the element of largest absolute value of a complex Hermitian matrix A in RFP format.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | norm | |||
| character, | intent(in) | :: | transr | |||
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=dp), | intent(in) | :: | a(0:*) | |||
| real(kind=dp), | intent(out) | :: | work(0:*) |
LANHP returns the value of the one norm, or the Frobenius norm, or the infinity norm, or the element of largest absolute value of a complex hermitian matrix A, supplied in packed form.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | norm | |||
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=sp), | intent(in) | :: | ap(*) | |||
| real(kind=sp), | intent(out) | :: | work(*) |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | norm | |||
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=dp), | intent(in) | :: | ap(*) | |||
| real(kind=dp), | intent(out) | :: | work(*) |
CLANHP returns the value of the one norm, or the Frobenius norm, or the infinity norm, or the element of largest absolute value of a complex hermitian matrix A, supplied in packed form.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | norm | |||
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=sp), | intent(in) | :: | ap(*) | |||
| real(kind=sp), | intent(out) | :: | work(*) |
ZLANHP returns the value of the one norm, or the Frobenius norm, or the infinity norm, or the element of largest absolute value of a complex hermitian matrix A, supplied in packed form.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | norm | |||
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=dp), | intent(in) | :: | ap(*) | |||
| real(kind=dp), | intent(out) | :: | work(*) |
LANHS returns the value of the one norm, or the Frobenius norm, or the infinity norm, or the element of largest absolute value of a Hessenberg matrix A.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | norm | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=sp), | intent(in) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=sp), | intent(out) | :: | work(*) |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | norm | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=dp), | intent(in) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=dp), | intent(out) | :: | work(*) |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | norm | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=sp), | intent(in) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=sp), | intent(out) | :: | work(*) |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | norm | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=dp), | intent(in) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=dp), | intent(out) | :: | work(*) |
CLANHS returns the value of the one norm, or the Frobenius norm, or the infinity norm, or the element of largest absolute value of a Hessenberg matrix A.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | norm | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=sp), | intent(in) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=sp), | intent(out) | :: | work(*) |
DLANHS returns the value of the one norm, or the Frobenius norm, or the infinity norm, or the element of largest absolute value of a Hessenberg matrix A.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | norm | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=dp), | intent(in) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=dp), | intent(out) | :: | work(*) |
SLANHS returns the value of the one norm, or the Frobenius norm, or the infinity norm, or the element of largest absolute value of a Hessenberg matrix A.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | norm | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=sp), | intent(in) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=sp), | intent(out) | :: | work(*) |
ZLANHS returns the value of the one norm, or the Frobenius norm, or the infinity norm, or the element of largest absolute value of a Hessenberg matrix A.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | norm | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=dp), | intent(in) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=dp), | intent(out) | :: | work(*) |
LANHT returns the value of the one norm, or the Frobenius norm, or the infinity norm, or the element of largest absolute value of a complex Hermitian tridiagonal matrix A.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | norm | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=sp), | intent(in) | :: | d(*) | |||
| complex(kind=sp), | intent(in) | :: | e(*) |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | norm | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=dp), | intent(in) | :: | d(*) | |||
| complex(kind=dp), | intent(in) | :: | e(*) |
CLANHT returns the value of the one norm, or the Frobenius norm, or the infinity norm, or the element of largest absolute value of a complex Hermitian tridiagonal matrix A.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | norm | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=sp), | intent(in) | :: | d(*) | |||
| complex(kind=sp), | intent(in) | :: | e(*) |
ZLANHT returns the value of the one norm, or the Frobenius norm, or the infinity norm, or the element of largest absolute value of a complex Hermitian tridiagonal matrix A.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | norm | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=dp), | intent(in) | :: | d(*) | |||
| complex(kind=dp), | intent(in) | :: | e(*) |
LANSB returns the value of the one norm, or the Frobenius norm, or the infinity norm, or the element of largest absolute value of an n by n symmetric band matrix A, with k super-diagonals.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | norm | |||
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | k | |||
| complex(kind=sp), | intent(in) | :: | ab(ldab,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldab | |||
| real(kind=sp), | intent(out) | :: | work(*) |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | norm | |||
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | k | |||
| real(kind=dp), | intent(in) | :: | ab(ldab,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldab | |||
| real(kind=dp), | intent(out) | :: | work(*) |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | norm | |||
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | k | |||
| real(kind=sp), | intent(in) | :: | ab(ldab,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldab | |||
| real(kind=sp), | intent(out) | :: | work(*) |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | norm | |||
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | k | |||
| complex(kind=dp), | intent(in) | :: | ab(ldab,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldab | |||
| real(kind=dp), | intent(out) | :: | work(*) |
CLANSB returns the value of the one norm, or the Frobenius norm, or the infinity norm, or the element of largest absolute value of an n by n symmetric band matrix A, with k super-diagonals.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | norm | |||
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | k | |||
| complex(kind=sp), | intent(in) | :: | ab(ldab,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldab | |||
| real(kind=sp), | intent(out) | :: | work(*) |
DLANSB returns the value of the one norm, or the Frobenius norm, or the infinity norm, or the element of largest absolute value of an n by n symmetric band matrix A, with k super-diagonals.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | norm | |||
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | k | |||
| real(kind=dp), | intent(in) | :: | ab(ldab,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldab | |||
| real(kind=dp), | intent(out) | :: | work(*) |
SLANSB returns the value of the one norm, or the Frobenius norm, or the infinity norm, or the element of largest absolute value of an n by n symmetric band matrix A, with k super-diagonals.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | norm | |||
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | k | |||
| real(kind=sp), | intent(in) | :: | ab(ldab,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldab | |||
| real(kind=sp), | intent(out) | :: | work(*) |
ZLANSB returns the value of the one norm, or the Frobenius norm, or the infinity norm, or the element of largest absolute value of an n by n symmetric band matrix A, with k super-diagonals.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | norm | |||
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | k | |||
| complex(kind=dp), | intent(in) | :: | ab(ldab,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldab | |||
| real(kind=dp), | intent(out) | :: | work(*) |
LANSF returns the value of the one norm, or the Frobenius norm, or the infinity norm, or the element of largest absolute value of a real symmetric matrix A in RFP format.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | norm | |||
| character, | intent(in) | :: | transr | |||
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=dp), | intent(in) | :: | a(0:*) | |||
| real(kind=dp), | intent(out) | :: | work(0:*) |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | norm | |||
| character, | intent(in) | :: | transr | |||
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=sp), | intent(in) | :: | a(0:*) | |||
| real(kind=sp), | intent(out) | :: | work(0:*) |
DLANSF returns the value of the one norm, or the Frobenius norm, or the infinity norm, or the element of largest absolute value of a real symmetric matrix A in RFP format.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | norm | |||
| character, | intent(in) | :: | transr | |||
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=dp), | intent(in) | :: | a(0:*) | |||
| real(kind=dp), | intent(out) | :: | work(0:*) |
SLANSF returns the value of the one norm, or the Frobenius norm, or the infinity norm, or the element of largest absolute value of a real symmetric matrix A in RFP format.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | norm | |||
| character, | intent(in) | :: | transr | |||
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=sp), | intent(in) | :: | a(0:*) | |||
| real(kind=sp), | intent(out) | :: | work(0:*) |
LANSP returns the value of the one norm, or the Frobenius norm, or the infinity norm, or the element of largest absolute value of a complex symmetric matrix A, supplied in packed form.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | norm | |||
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=sp), | intent(in) | :: | ap(*) | |||
| real(kind=sp), | intent(out) | :: | work(*) |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | norm | |||
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=dp), | intent(in) | :: | ap(*) | |||
| real(kind=dp), | intent(out) | :: | work(*) |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | norm | |||
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=sp), | intent(in) | :: | ap(*) | |||
| real(kind=sp), | intent(out) | :: | work(*) |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | norm | |||
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=dp), | intent(in) | :: | ap(*) | |||
| real(kind=dp), | intent(out) | :: | work(*) |
CLANSP returns the value of the one norm, or the Frobenius norm, or the infinity norm, or the element of largest absolute value of a complex symmetric matrix A, supplied in packed form.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | norm | |||
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=sp), | intent(in) | :: | ap(*) | |||
| real(kind=sp), | intent(out) | :: | work(*) |
DLANSP returns the value of the one norm, or the Frobenius norm, or the infinity norm, or the element of largest absolute value of a real symmetric matrix A, supplied in packed form.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | norm | |||
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=dp), | intent(in) | :: | ap(*) | |||
| real(kind=dp), | intent(out) | :: | work(*) |
SLANSP returns the value of the one norm, or the Frobenius norm, or the infinity norm, or the element of largest absolute value of a real symmetric matrix A, supplied in packed form.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | norm | |||
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=sp), | intent(in) | :: | ap(*) | |||
| real(kind=sp), | intent(out) | :: | work(*) |
ZLANSP returns the value of the one norm, or the Frobenius norm, or the infinity norm, or the element of largest absolute value of a complex symmetric matrix A, supplied in packed form.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | norm | |||
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=dp), | intent(in) | :: | ap(*) | |||
| real(kind=dp), | intent(out) | :: | work(*) |
LANST returns the value of the one norm, or the Frobenius norm, or the infinity norm, or the element of largest absolute value of a real symmetric tridiagonal matrix A.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | norm | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=dp), | intent(in) | :: | d(*) | |||
| real(kind=dp), | intent(in) | :: | e(*) |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | norm | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=sp), | intent(in) | :: | d(*) | |||
| real(kind=sp), | intent(in) | :: | e(*) |
DLANST returns the value of the one norm, or the Frobenius norm, or the infinity norm, or the element of largest absolute value of a real symmetric tridiagonal matrix A.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | norm | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=dp), | intent(in) | :: | d(*) | |||
| real(kind=dp), | intent(in) | :: | e(*) |
SLANST returns the value of the one norm, or the Frobenius norm, or the infinity norm, or the element of largest absolute value of a real symmetric tridiagonal matrix A.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | norm | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=sp), | intent(in) | :: | d(*) | |||
| real(kind=sp), | intent(in) | :: | e(*) |
LANSY returns the value of the one norm, or the Frobenius norm, or the infinity norm, or the element of largest absolute value of a complex symmetric matrix A.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | norm | |||
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=sp), | intent(in) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=sp), | intent(out) | :: | work(*) |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | norm | |||
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=dp), | intent(in) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=dp), | intent(out) | :: | work(*) |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | norm | |||
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=sp), | intent(in) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=sp), | intent(out) | :: | work(*) |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | norm | |||
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=dp), | intent(in) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=dp), | intent(out) | :: | work(*) |
CLANSY returns the value of the one norm, or the Frobenius norm, or the infinity norm, or the element of largest absolute value of a complex symmetric matrix A.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | norm | |||
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=sp), | intent(in) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=sp), | intent(out) | :: | work(*) |
DLANSY returns the value of the one norm, or the Frobenius norm, or the infinity norm, or the element of largest absolute value of a real symmetric matrix A.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | norm | |||
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=dp), | intent(in) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=dp), | intent(out) | :: | work(*) |
SLANSY returns the value of the one norm, or the Frobenius norm, or the infinity norm, or the element of largest absolute value of a real symmetric matrix A.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | norm | |||
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=sp), | intent(in) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=sp), | intent(out) | :: | work(*) |
ZLANSY returns the value of the one norm, or the Frobenius norm, or the infinity norm, or the element of largest absolute value of a complex symmetric matrix A.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | norm | |||
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=dp), | intent(in) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=dp), | intent(out) | :: | work(*) |
LANTB returns the value of the one norm, or the Frobenius norm, or the infinity norm, or the element of largest absolute value of an n by n triangular band matrix A, with ( k + 1 ) diagonals.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | norm | |||
| character, | intent(in) | :: | uplo | |||
| character, | intent(in) | :: | diag | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | k | |||
| complex(kind=sp), | intent(in) | :: | ab(ldab,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldab | |||
| real(kind=sp), | intent(out) | :: | work(*) |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | norm | |||
| character, | intent(in) | :: | uplo | |||
| character, | intent(in) | :: | diag | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | k | |||
| real(kind=dp), | intent(in) | :: | ab(ldab,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldab | |||
| real(kind=dp), | intent(out) | :: | work(*) |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | norm | |||
| character, | intent(in) | :: | uplo | |||
| character, | intent(in) | :: | diag | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | k | |||
| real(kind=sp), | intent(in) | :: | ab(ldab,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldab | |||
| real(kind=sp), | intent(out) | :: | work(*) |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | norm | |||
| character, | intent(in) | :: | uplo | |||
| character, | intent(in) | :: | diag | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | k | |||
| complex(kind=dp), | intent(in) | :: | ab(ldab,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldab | |||
| real(kind=dp), | intent(out) | :: | work(*) |
CLANTB returns the value of the one norm, or the Frobenius norm, or the infinity norm, or the element of largest absolute value of an n by n triangular band matrix A, with ( k + 1 ) diagonals.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | norm | |||
| character, | intent(in) | :: | uplo | |||
| character, | intent(in) | :: | diag | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | k | |||
| complex(kind=sp), | intent(in) | :: | ab(ldab,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldab | |||
| real(kind=sp), | intent(out) | :: | work(*) |
DLANTB returns the value of the one norm, or the Frobenius norm, or the infinity norm, or the element of largest absolute value of an n by n triangular band matrix A, with ( k + 1 ) diagonals.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | norm | |||
| character, | intent(in) | :: | uplo | |||
| character, | intent(in) | :: | diag | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | k | |||
| real(kind=dp), | intent(in) | :: | ab(ldab,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldab | |||
| real(kind=dp), | intent(out) | :: | work(*) |
SLANTB returns the value of the one norm, or the Frobenius norm, or the infinity norm, or the element of largest absolute value of an n by n triangular band matrix A, with ( k + 1 ) diagonals.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | norm | |||
| character, | intent(in) | :: | uplo | |||
| character, | intent(in) | :: | diag | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | k | |||
| real(kind=sp), | intent(in) | :: | ab(ldab,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldab | |||
| real(kind=sp), | intent(out) | :: | work(*) |
ZLANTB returns the value of the one norm, or the Frobenius norm, or the infinity norm, or the element of largest absolute value of an n by n triangular band matrix A, with ( k + 1 ) diagonals.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | norm | |||
| character, | intent(in) | :: | uplo | |||
| character, | intent(in) | :: | diag | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | k | |||
| complex(kind=dp), | intent(in) | :: | ab(ldab,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldab | |||
| real(kind=dp), | intent(out) | :: | work(*) |
LANTP returns the value of the one norm, or the Frobenius norm, or the infinity norm, or the element of largest absolute value of a triangular matrix A, supplied in packed form.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | norm | |||
| character, | intent(in) | :: | uplo | |||
| character, | intent(in) | :: | diag | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=sp), | intent(in) | :: | ap(*) | |||
| real(kind=sp), | intent(out) | :: | work(*) |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | norm | |||
| character, | intent(in) | :: | uplo | |||
| character, | intent(in) | :: | diag | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=dp), | intent(in) | :: | ap(*) | |||
| real(kind=dp), | intent(out) | :: | work(*) |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | norm | |||
| character, | intent(in) | :: | uplo | |||
| character, | intent(in) | :: | diag | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=sp), | intent(in) | :: | ap(*) | |||
| real(kind=sp), | intent(out) | :: | work(*) |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | norm | |||
| character, | intent(in) | :: | uplo | |||
| character, | intent(in) | :: | diag | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=dp), | intent(in) | :: | ap(*) | |||
| real(kind=dp), | intent(out) | :: | work(*) |
CLANTP returns the value of the one norm, or the Frobenius norm, or the infinity norm, or the element of largest absolute value of a triangular matrix A, supplied in packed form.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | norm | |||
| character, | intent(in) | :: | uplo | |||
| character, | intent(in) | :: | diag | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=sp), | intent(in) | :: | ap(*) | |||
| real(kind=sp), | intent(out) | :: | work(*) |
DLANTP returns the value of the one norm, or the Frobenius norm, or the infinity norm, or the element of largest absolute value of a triangular matrix A, supplied in packed form.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | norm | |||
| character, | intent(in) | :: | uplo | |||
| character, | intent(in) | :: | diag | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=dp), | intent(in) | :: | ap(*) | |||
| real(kind=dp), | intent(out) | :: | work(*) |
SLANTP returns the value of the one norm, or the Frobenius norm, or the infinity norm, or the element of largest absolute value of a triangular matrix A, supplied in packed form.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | norm | |||
| character, | intent(in) | :: | uplo | |||
| character, | intent(in) | :: | diag | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=sp), | intent(in) | :: | ap(*) | |||
| real(kind=sp), | intent(out) | :: | work(*) |
ZLANTP returns the value of the one norm, or the Frobenius norm, or the infinity norm, or the element of largest absolute value of a triangular matrix A, supplied in packed form.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | norm | |||
| character, | intent(in) | :: | uplo | |||
| character, | intent(in) | :: | diag | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=dp), | intent(in) | :: | ap(*) | |||
| real(kind=dp), | intent(out) | :: | work(*) |
LANTR returns the value of the one norm, or the Frobenius norm, or the infinity norm, or the element of largest absolute value of a trapezoidal or triangular matrix A.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | norm | |||
| character, | intent(in) | :: | uplo | |||
| character, | intent(in) | :: | diag | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=sp), | intent(in) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=sp), | intent(out) | :: | work(*) |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | norm | |||
| character, | intent(in) | :: | uplo | |||
| character, | intent(in) | :: | diag | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=dp), | intent(in) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=dp), | intent(out) | :: | work(*) |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | norm | |||
| character, | intent(in) | :: | uplo | |||
| character, | intent(in) | :: | diag | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=sp), | intent(in) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=sp), | intent(out) | :: | work(*) |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | norm | |||
| character, | intent(in) | :: | uplo | |||
| character, | intent(in) | :: | diag | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=dp), | intent(in) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=dp), | intent(out) | :: | work(*) |
CLANTR returns the value of the one norm, or the Frobenius norm, or the infinity norm, or the element of largest absolute value of a trapezoidal or triangular matrix A.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | norm | |||
| character, | intent(in) | :: | uplo | |||
| character, | intent(in) | :: | diag | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=sp), | intent(in) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=sp), | intent(out) | :: | work(*) |
DLANTR returns the value of the one norm, or the Frobenius norm, or the infinity norm, or the element of largest absolute value of a trapezoidal or triangular matrix A.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | norm | |||
| character, | intent(in) | :: | uplo | |||
| character, | intent(in) | :: | diag | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=dp), | intent(in) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=dp), | intent(out) | :: | work(*) |
SLANTR returns the value of the one norm, or the Frobenius norm, or the infinity norm, or the element of largest absolute value of a trapezoidal or triangular matrix A.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | norm | |||
| character, | intent(in) | :: | uplo | |||
| character, | intent(in) | :: | diag | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=sp), | intent(in) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=sp), | intent(out) | :: | work(*) |
ZLANTR returns the value of the one norm, or the Frobenius norm, or the infinity norm, or the element of largest absolute value of a trapezoidal or triangular matrix A.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | norm | |||
| character, | intent(in) | :: | uplo | |||
| character, | intent(in) | :: | diag | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=dp), | intent(in) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=dp), | intent(out) | :: | work(*) |
LAORHR_COL_GETRFNP computes the modified LU factorization without pivoting of a real general M-by-N matrix A. The factorization has the form: A - S = L * U, where: S is a m-by-n diagonal sign matrix with the diagonal D, so that D(i) = S(i,i), 1 <= i <= min(M,N). The diagonal D is constructed as D(i)=-SIGN(A(i,i)), where A(i,i) is the value after performing i-1 steps of Gaussian elimination. This means that the diagonal element at each step of "modified" Gaussian elimination is at least one in absolute value (so that division-by-zero not not possible during the division by the diagonal element); L is a M-by-N lower triangular matrix with unit diagonal elements (lower trapezoidal if M > N); and U is a M-by-N upper triangular matrix (upper trapezoidal if M < N). This routine is an auxiliary routine used in the Householder reconstruction routine DORHR_COL. In DORHR_COL, this routine is applied to an M-by-N matrix A with orthonormal columns, where each element is bounded by one in absolute value. With the choice of the matrix S above, one can show that the diagonal element at each step of Gaussian elimination is the largest (in absolute value) in the column on or below the diagonal, so that no pivoting is required for numerical stability [1]. For more details on the Householder reconstruction algorithm, including the modified LU factorization, see [1]. This is the blocked right-looking version of the algorithm, calling Level 3 BLAS to update the submatrix. To factorize a block, this routine calls the recursive routine LAORHR_COL_GETRFNP2. [1] "Reconstructing Householder vectors from tall-skinny QR", G. Ballard, J. Demmel, L. Grigori, M. Jacquelin, H.D. Nguyen, E. Solomonik, J. Parallel Distrib. Comput., vol. 85, pp. 3-31, 2015.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=dp), | intent(out) | :: | d(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=sp), | intent(out) | :: | d(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
DLAORHR_COL_GETRFNP computes the modified LU factorization without pivoting of a real general M-by-N matrix A. The factorization has the form: A - S = L * U, where: S is a m-by-n diagonal sign matrix with the diagonal D, so that D(i) = S(i,i), 1 <= i <= min(M,N). The diagonal D is constructed as D(i)=-SIGN(A(i,i)), where A(i,i) is the value after performing i-1 steps of Gaussian elimination. This means that the diagonal element at each step of "modified" Gaussian elimination is at least one in absolute value (so that division-by-zero not not possible during the division by the diagonal element); L is a M-by-N lower triangular matrix with unit diagonal elements (lower trapezoidal if M > N); and U is a M-by-N upper triangular matrix (upper trapezoidal if M < N). This routine is an auxiliary routine used in the Householder reconstruction routine DORHR_COL. In DORHR_COL, this routine is applied to an M-by-N matrix A with orthonormal columns, where each element is bounded by one in absolute value. With the choice of the matrix S above, one can show that the diagonal element at each step of Gaussian elimination is the largest (in absolute value) in the column on or below the diagonal, so that no pivoting is required for numerical stability [1]. For more details on the Householder reconstruction algorithm, including the modified LU factorization, see [1]. This is the blocked right-looking version of the algorithm, calling Level 3 BLAS to update the submatrix. To factorize a block, this routine calls the recursive routine DLAORHR_COL_GETRFNP2. [1] "Reconstructing Householder vectors from tall-skinny QR", G. Ballard, J. Demmel, L. Grigori, M. Jacquelin, H.D. Nguyen, E. Solomonik, J. Parallel Distrib. Comput., vol. 85, pp. 3-31, 2015.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=dp), | intent(out) | :: | d(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
SLAORHR_COL_GETRFNP computes the modified LU factorization without pivoting of a real general M-by-N matrix A. The factorization has the form: A - S = L * U, where: S is a m-by-n diagonal sign matrix with the diagonal D, so that D(i) = S(i,i), 1 <= i <= min(M,N). The diagonal D is constructed as D(i)=-SIGN(A(i,i)), where A(i,i) is the value after performing i-1 steps of Gaussian elimination. This means that the diagonal element at each step of "modified" Gaussian elimination is at least one in absolute value (so that division-by-zero not not possible during the division by the diagonal element); L is a M-by-N lower triangular matrix with unit diagonal elements (lower trapezoidal if M > N); and U is a M-by-N upper triangular matrix (upper trapezoidal if M < N). This routine is an auxiliary routine used in the Householder reconstruction routine SORHR_COL. In SORHR_COL, this routine is applied to an M-by-N matrix A with orthonormal columns, where each element is bounded by one in absolute value. With the choice of the matrix S above, one can show that the diagonal element at each step of Gaussian elimination is the largest (in absolute value) in the column on or below the diagonal, so that no pivoting is required for numerical stability [1]. For more details on the Householder reconstruction algorithm, including the modified LU factorization, see [1]. This is the blocked right-looking version of the algorithm, calling Level 3 BLAS to update the submatrix. To factorize a block, this routine calls the recursive routine SLAORHR_COL_GETRFNP2. [1] "Reconstructing Householder vectors from tall-skinny QR", G. Ballard, J. Demmel, L. Grigori, M. Jacquelin, H.D. Nguyen, E. Solomonik, J. Parallel Distrib. Comput., vol. 85, pp. 3-31, 2015.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=sp), | intent(out) | :: | d(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
LAORHR_COL_GETRFNP2 computes the modified LU factorization without pivoting of a real general M-by-N matrix A. The factorization has the form: A - S = L * U, where: S is a m-by-n diagonal sign matrix with the diagonal D, so that D(i) = S(i,i), 1 <= i <= min(M,N). The diagonal D is constructed as D(i)=-SIGN(A(i,i)), where A(i,i) is the value after performing i-1 steps of Gaussian elimination. This means that the diagonal element at each step of "modified" Gaussian elimination is at least one in absolute value (so that division-by-zero not possible during the division by the diagonal element); L is a M-by-N lower triangular matrix with unit diagonal elements (lower trapezoidal if M > N); and U is a M-by-N upper triangular matrix (upper trapezoidal if M < N). This routine is an auxiliary routine used in the Householder reconstruction routine DORHR_COL. In DORHR_COL, this routine is applied to an M-by-N matrix A with orthonormal columns, where each element is bounded by one in absolute value. With the choice of the matrix S above, one can show that the diagonal element at each step of Gaussian elimination is the largest (in absolute value) in the column on or below the diagonal, so that no pivoting is required for numerical stability [1]. For more details on the Householder reconstruction algorithm, including the modified LU factorization, see [1]. This is the recursive version of the LU factorization algorithm. Denote A - S by B. The algorithm divides the matrix B into four submatrices: [ B11 | B12 ] where B11 is n1 by n1, B = [ -----|----- ] B21 is (m-n1) by n1, [ B21 | B22 ] B12 is n1 by n2, B22 is (m-n1) by n2, with n1 = min(m,n)/2, n2 = n-n1. The subroutine calls itself to factor B11, solves for B21, solves for B12, updates B22, then calls itself to factor B22. For more details on the recursive LU algorithm, see [2]. LAORHR_COL_GETRFNP2 is called to factorize a block by the blocked routine DLAORHR_COL_GETRFNP, which uses blocked code calling Level 3 BLAS to update the submatrix. However, LAORHR_COL_GETRFNP2 is self-sufficient and can be used without DLAORHR_COL_GETRFNP. [1] "Reconstructing Householder vectors from tall-skinny QR", G. Ballard, J. Demmel, L. Grigori, M. Jacquelin, H.D. Nguyen, E. Solomonik, J. Parallel Distrib. Comput., vol. 85, pp. 3-31, 2015. [2] "Recursion leads to automatic variable blocking for dense linear algebra algorithms", F. Gustavson, IBM J. of Res. and Dev., vol. 41, no. 6, pp. 737-755, 1997.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=dp), | intent(out) | :: | d(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=sp), | intent(out) | :: | d(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
DLAORHR_COL_GETRFNP2 computes the modified LU factorization without pivoting of a real general M-by-N matrix A. The factorization has the form: A - S = L * U, where: S is a m-by-n diagonal sign matrix with the diagonal D, so that D(i) = S(i,i), 1 <= i <= min(M,N). The diagonal D is constructed as D(i)=-SIGN(A(i,i)), where A(i,i) is the value after performing i-1 steps of Gaussian elimination. This means that the diagonal element at each step of "modified" Gaussian elimination is at least one in absolute value (so that division-by-zero not possible during the division by the diagonal element); L is a M-by-N lower triangular matrix with unit diagonal elements (lower trapezoidal if M > N); and U is a M-by-N upper triangular matrix (upper trapezoidal if M < N). This routine is an auxiliary routine used in the Householder reconstruction routine DORHR_COL. In DORHR_COL, this routine is applied to an M-by-N matrix A with orthonormal columns, where each element is bounded by one in absolute value. With the choice of the matrix S above, one can show that the diagonal element at each step of Gaussian elimination is the largest (in absolute value) in the column on or below the diagonal, so that no pivoting is required for numerical stability [1]. For more details on the Householder reconstruction algorithm, including the modified LU factorization, see [1]. This is the recursive version of the LU factorization algorithm. Denote A - S by B. The algorithm divides the matrix B into four submatrices: [ B11 | B12 ] where B11 is n1 by n1, B = [ -----|----- ] B21 is (m-n1) by n1, [ B21 | B22 ] B12 is n1 by n2, B22 is (m-n1) by n2, with n1 = min(m,n)/2, n2 = n-n1. The subroutine calls itself to factor B11, solves for B21, solves for B12, updates B22, then calls itself to factor B22. For more details on the recursive LU algorithm, see [2]. DLAORHR_COL_GETRFNP2 is called to factorize a block by the blocked routine DLAORHR_COL_GETRFNP, which uses blocked code calling Level 3 BLAS to update the submatrix. However, DLAORHR_COL_GETRFNP2 is self-sufficient and can be used without DLAORHR_COL_GETRFNP. [1] "Reconstructing Householder vectors from tall-skinny QR", G. Ballard, J. Demmel, L. Grigori, M. Jacquelin, H.D. Nguyen, E. Solomonik, J. Parallel Distrib. Comput., vol. 85, pp. 3-31, 2015. [2] "Recursion leads to automatic variable blocking for dense linear algebra algorithms", F. Gustavson, IBM J. of Res. and Dev., vol. 41, no. 6, pp. 737-755, 1997.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=dp), | intent(out) | :: | d(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
SLAORHR_COL_GETRFNP2 computes the modified LU factorization without pivoting of a real general M-by-N matrix A. The factorization has the form: A - S = L * U, where: S is a m-by-n diagonal sign matrix with the diagonal D, so that D(i) = S(i,i), 1 <= i <= min(M,N). The diagonal D is constructed as D(i)=-SIGN(A(i,i)), where A(i,i) is the value after performing i-1 steps of Gaussian elimination. This means that the diagonal element at each step of "modified" Gaussian elimination is at least one in absolute value (so that division-by-zero not possible during the division by the diagonal element); L is a M-by-N lower triangular matrix with unit diagonal elements (lower trapezoidal if M > N); and U is a M-by-N upper triangular matrix (upper trapezoidal if M < N). This routine is an auxiliary routine used in the Householder reconstruction routine SORHR_COL. In SORHR_COL, this routine is applied to an M-by-N matrix A with orthonormal columns, where each element is bounded by one in absolute value. With the choice of the matrix S above, one can show that the diagonal element at each step of Gaussian elimination is the largest (in absolute value) in the column on or below the diagonal, so that no pivoting is required for numerical stability [1]. For more details on the Householder reconstruction algorithm, including the modified LU factorization, see [1]. This is the recursive version of the LU factorization algorithm. Denote A - S by B. The algorithm divides the matrix B into four submatrices: [ B11 | B12 ] where B11 is n1 by n1, B = [ -----|----- ] B21 is (m-n1) by n1, [ B21 | B22 ] B12 is n1 by n2, B22 is (m-n1) by n2, with n1 = min(m,n)/2, n2 = n-n1. The subroutine calls itself to factor B11, solves for B21, solves for B12, updates B22, then calls itself to factor B22. For more details on the recursive LU algorithm, see [2]. SLAORHR_COL_GETRFNP2 is called to factorize a block by the blocked routine SLAORHR_COL_GETRFNP, which uses blocked code calling Level 3 BLAS to update the submatrix. However, SLAORHR_COL_GETRFNP2 is self-sufficient and can be used without SLAORHR_COL_GETRFNP. [1] "Reconstructing Householder vectors from tall-skinny QR", G. Ballard, J. Demmel, L. Grigori, M. Jacquelin, H.D. Nguyen, E. Solomonik, J. Parallel Distrib. Comput., vol. 85, pp. 3-31, 2015. [2] "Recursion leads to automatic variable blocking for dense linear algebra algorithms", F. Gustavson, IBM J. of Res. and Dev., vol. 41, no. 6, pp. 737-755, 1997.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=sp), | intent(out) | :: | d(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
Given two column vectors X and Y, let A = ( X Y ). The subroutine first computes the QR factorization of A = Q*R, and then computes the SVD of the 2-by-2 upper triangular matrix R. The smaller singular value of R is returned in SSMIN, which is used as the measurement of the linear dependency of the vectors X and Y.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=sp), | intent(inout) | :: | x(*) | |||
| integer(kind=ilp), | intent(in) | :: | incx | |||
| complex(kind=sp), | intent(inout) | :: | y(*) | |||
| integer(kind=ilp), | intent(in) | :: | incy | |||
| real(kind=sp), | intent(out) | :: | ssmin |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=dp), | intent(inout) | :: | x(*) | |||
| integer(kind=ilp), | intent(in) | :: | incx | |||
| real(kind=dp), | intent(inout) | :: | y(*) | |||
| integer(kind=ilp), | intent(in) | :: | incy | |||
| real(kind=dp), | intent(out) | :: | ssmin |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=sp), | intent(inout) | :: | x(*) | |||
| integer(kind=ilp), | intent(in) | :: | incx | |||
| real(kind=sp), | intent(inout) | :: | y(*) | |||
| integer(kind=ilp), | intent(in) | :: | incy | |||
| real(kind=sp), | intent(out) | :: | ssmin |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=dp), | intent(inout) | :: | x(*) | |||
| integer(kind=ilp), | intent(in) | :: | incx | |||
| complex(kind=dp), | intent(inout) | :: | y(*) | |||
| integer(kind=ilp), | intent(in) | :: | incy | |||
| real(kind=dp), | intent(out) | :: | ssmin |
Given two column vectors X and Y, let A = ( X Y ). The subroutine first computes the QR factorization of A = Q*R, and then computes the SVD of the 2-by-2 upper triangular matrix R. The smaller singular value of R is returned in SSMIN, which is used as the measurement of the linear dependency of the vectors X and Y.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=sp), | intent(inout) | :: | x(*) | |||
| integer(kind=ilp), | intent(in) | :: | incx | |||
| complex(kind=sp), | intent(inout) | :: | y(*) | |||
| integer(kind=ilp), | intent(in) | :: | incy | |||
| real(kind=sp), | intent(out) | :: | ssmin |
Given two column vectors X and Y, let A = ( X Y ). The subroutine first computes the QR factorization of A = Q*R, and then computes the SVD of the 2-by-2 upper triangular matrix R. The smaller singular value of R is returned in SSMIN, which is used as the measurement of the linear dependency of the vectors X and Y.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=dp), | intent(inout) | :: | x(*) | |||
| integer(kind=ilp), | intent(in) | :: | incx | |||
| real(kind=dp), | intent(inout) | :: | y(*) | |||
| integer(kind=ilp), | intent(in) | :: | incy | |||
| real(kind=dp), | intent(out) | :: | ssmin |
Given two column vectors X and Y, let A = ( X Y ). The subroutine first computes the QR factorization of A = Q*R, and then computes the SVD of the 2-by-2 upper triangular matrix R. The smaller singular value of R is returned in SSMIN, which is used as the measurement of the linear dependency of the vectors X and Y.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=sp), | intent(inout) | :: | x(*) | |||
| integer(kind=ilp), | intent(in) | :: | incx | |||
| real(kind=sp), | intent(inout) | :: | y(*) | |||
| integer(kind=ilp), | intent(in) | :: | incy | |||
| real(kind=sp), | intent(out) | :: | ssmin |
Given two column vectors X and Y, let A = ( X Y ). The subroutine first computes the QR factorization of A = Q*R, and then computes the SVD of the 2-by-2 upper triangular matrix R. The smaller singular value of R is returned in SSMIN, which is used as the measurement of the linear dependency of the vectors X and Y.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=dp), | intent(inout) | :: | x(*) | |||
| integer(kind=ilp), | intent(in) | :: | incx | |||
| complex(kind=dp), | intent(inout) | :: | y(*) | |||
| integer(kind=ilp), | intent(in) | :: | incy | |||
| real(kind=dp), | intent(out) | :: | ssmin |
LAPMR rearranges the rows of the M by N matrix X as specified by the permutation K(1),K(2),...,K(M) of the integers 1,...,M. If FORWRD = .TRUE., forward permutation: X(K(I),) is moved X(I,) for I = 1,2,...,M. If FORWRD = .FALSE., backward permutation: X(I,) is moved to X(K(I),) for I = 1,2,...,M.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| logical(kind=lk), | intent(in) | :: | forwrd | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=sp), | intent(inout) | :: | x(ldx,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldx | |||
| integer(kind=ilp), | intent(inout) | :: | k(*) |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| logical(kind=lk), | intent(in) | :: | forwrd | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=dp), | intent(inout) | :: | x(ldx,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldx | |||
| integer(kind=ilp), | intent(inout) | :: | k(*) |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| logical(kind=lk), | intent(in) | :: | forwrd | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=sp), | intent(inout) | :: | x(ldx,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldx | |||
| integer(kind=ilp), | intent(inout) | :: | k(*) |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| logical(kind=lk), | intent(in) | :: | forwrd | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=dp), | intent(inout) | :: | x(ldx,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldx | |||
| integer(kind=ilp), | intent(inout) | :: | k(*) |
CLAPMR rearranges the rows of the M by N matrix X as specified by the permutation K(1),K(2),...,K(M) of the integers 1,...,M. If FORWRD = .TRUE., forward permutation: X(K(I),) is moved X(I,) for I = 1,2,...,M. If FORWRD = .FALSE., backward permutation: X(I,) is moved to X(K(I),) for I = 1,2,...,M.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| logical(kind=lk), | intent(in) | :: | forwrd | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=sp), | intent(inout) | :: | x(ldx,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldx | |||
| integer(kind=ilp), | intent(inout) | :: | k(*) |
DLAPMR rearranges the rows of the M by N matrix X as specified by the permutation K(1),K(2),...,K(M) of the integers 1,...,M. If FORWRD = .TRUE., forward permutation: X(K(I),) is moved X(I,) for I = 1,2,...,M. If FORWRD = .FALSE., backward permutation: X(I,) is moved to X(K(I),) for I = 1,2,...,M.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| logical(kind=lk), | intent(in) | :: | forwrd | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=dp), | intent(inout) | :: | x(ldx,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldx | |||
| integer(kind=ilp), | intent(inout) | :: | k(*) |
SLAPMR rearranges the rows of the M by N matrix X as specified by the permutation K(1),K(2),...,K(M) of the integers 1,...,M. If FORWRD = .TRUE., forward permutation: X(K(I),) is moved X(I,) for I = 1,2,...,M. If FORWRD = .FALSE., backward permutation: X(I,) is moved to X(K(I),) for I = 1,2,...,M.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| logical(kind=lk), | intent(in) | :: | forwrd | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=sp), | intent(inout) | :: | x(ldx,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldx | |||
| integer(kind=ilp), | intent(inout) | :: | k(*) |
ZLAPMR rearranges the rows of the M by N matrix X as specified by the permutation K(1),K(2),...,K(M) of the integers 1,...,M. If FORWRD = .TRUE., forward permutation: X(K(I),) is moved X(I,) for I = 1,2,...,M. If FORWRD = .FALSE., backward permutation: X(I,) is moved to X(K(I),) for I = 1,2,...,M.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| logical(kind=lk), | intent(in) | :: | forwrd | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=dp), | intent(inout) | :: | x(ldx,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldx | |||
| integer(kind=ilp), | intent(inout) | :: | k(*) |
LAPMT rearranges the columns of the M by N matrix X as specified by the permutation K(1),K(2),...,K(N) of the integers 1,...,N. If FORWRD = .TRUE., forward permutation: X(,K(J)) is moved X(,J) for J = 1,2,...,N. If FORWRD = .FALSE., backward permutation: X(,J) is moved to X(,K(J)) for J = 1,2,...,N.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| logical(kind=lk), | intent(in) | :: | forwrd | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=sp), | intent(inout) | :: | x(ldx,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldx | |||
| integer(kind=ilp), | intent(inout) | :: | k(*) |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| logical(kind=lk), | intent(in) | :: | forwrd | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=dp), | intent(inout) | :: | x(ldx,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldx | |||
| integer(kind=ilp), | intent(inout) | :: | k(*) |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| logical(kind=lk), | intent(in) | :: | forwrd | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=sp), | intent(inout) | :: | x(ldx,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldx | |||
| integer(kind=ilp), | intent(inout) | :: | k(*) |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| logical(kind=lk), | intent(in) | :: | forwrd | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=dp), | intent(inout) | :: | x(ldx,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldx | |||
| integer(kind=ilp), | intent(inout) | :: | k(*) |
CLAPMT rearranges the columns of the M by N matrix X as specified by the permutation K(1),K(2),...,K(N) of the integers 1,...,N. If FORWRD = .TRUE., forward permutation: X(,K(J)) is moved X(,J) for J = 1,2,...,N. If FORWRD = .FALSE., backward permutation: X(,J) is moved to X(,K(J)) for J = 1,2,...,N.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| logical(kind=lk), | intent(in) | :: | forwrd | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=sp), | intent(inout) | :: | x(ldx,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldx | |||
| integer(kind=ilp), | intent(inout) | :: | k(*) |
DLAPMT rearranges the columns of the M by N matrix X as specified by the permutation K(1),K(2),...,K(N) of the integers 1,...,N. If FORWRD = .TRUE., forward permutation: X(,K(J)) is moved X(,J) for J = 1,2,...,N. If FORWRD = .FALSE., backward permutation: X(,J) is moved to X(,K(J)) for J = 1,2,...,N.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| logical(kind=lk), | intent(in) | :: | forwrd | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=dp), | intent(inout) | :: | x(ldx,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldx | |||
| integer(kind=ilp), | intent(inout) | :: | k(*) |
SLAPMT rearranges the columns of the M by N matrix X as specified by the permutation K(1),K(2),...,K(N) of the integers 1,...,N. If FORWRD = .TRUE., forward permutation: X(,K(J)) is moved X(,J) for J = 1,2,...,N. If FORWRD = .FALSE., backward permutation: X(,J) is moved to X(,K(J)) for J = 1,2,...,N.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| logical(kind=lk), | intent(in) | :: | forwrd | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=sp), | intent(inout) | :: | x(ldx,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldx | |||
| integer(kind=ilp), | intent(inout) | :: | k(*) |
ZLAPMT rearranges the columns of the M by N matrix X as specified by the permutation K(1),K(2),...,K(N) of the integers 1,...,N. If FORWRD = .TRUE., forward permutation: X(,K(J)) is moved X(,J) for J = 1,2,...,N. If FORWRD = .FALSE., backward permutation: X(,J) is moved to X(,K(J)) for J = 1,2,...,N.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| logical(kind=lk), | intent(in) | :: | forwrd | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=dp), | intent(inout) | :: | x(ldx,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldx | |||
| integer(kind=ilp), | intent(inout) | :: | k(*) |
LAQGB equilibrates a general M by N band matrix A with KL subdiagonals and KU superdiagonals using the row and scaling factors in the vectors R and C.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | kl | |||
| integer(kind=ilp), | intent(in) | :: | ku | |||
| complex(kind=sp), | intent(inout) | :: | ab(ldab,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldab | |||
| real(kind=sp), | intent(in) | :: | r(*) | |||
| real(kind=sp), | intent(in) | :: | c(*) | |||
| real(kind=sp), | intent(in) | :: | rowcnd | |||
| real(kind=sp), | intent(in) | :: | colcnd | |||
| real(kind=sp), | intent(in) | :: | amax | |||
| character, | intent(out) | :: | equed |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | kl | |||
| integer(kind=ilp), | intent(in) | :: | ku | |||
| real(kind=dp), | intent(inout) | :: | ab(ldab,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldab | |||
| real(kind=dp), | intent(in) | :: | r(*) | |||
| real(kind=dp), | intent(in) | :: | c(*) | |||
| real(kind=dp), | intent(in) | :: | rowcnd | |||
| real(kind=dp), | intent(in) | :: | colcnd | |||
| real(kind=dp), | intent(in) | :: | amax | |||
| character, | intent(out) | :: | equed |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | kl | |||
| integer(kind=ilp), | intent(in) | :: | ku | |||
| real(kind=sp), | intent(inout) | :: | ab(ldab,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldab | |||
| real(kind=sp), | intent(in) | :: | r(*) | |||
| real(kind=sp), | intent(in) | :: | c(*) | |||
| real(kind=sp), | intent(in) | :: | rowcnd | |||
| real(kind=sp), | intent(in) | :: | colcnd | |||
| real(kind=sp), | intent(in) | :: | amax | |||
| character, | intent(out) | :: | equed |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | kl | |||
| integer(kind=ilp), | intent(in) | :: | ku | |||
| complex(kind=dp), | intent(inout) | :: | ab(ldab,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldab | |||
| real(kind=dp), | intent(in) | :: | r(*) | |||
| real(kind=dp), | intent(in) | :: | c(*) | |||
| real(kind=dp), | intent(in) | :: | rowcnd | |||
| real(kind=dp), | intent(in) | :: | colcnd | |||
| real(kind=dp), | intent(in) | :: | amax | |||
| character, | intent(out) | :: | equed |
CLAQGB equilibrates a general M by N band matrix A with KL subdiagonals and KU superdiagonals using the row and scaling factors in the vectors R and C.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | kl | |||
| integer(kind=ilp), | intent(in) | :: | ku | |||
| complex(kind=sp), | intent(inout) | :: | ab(ldab,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldab | |||
| real(kind=sp), | intent(in) | :: | r(*) | |||
| real(kind=sp), | intent(in) | :: | c(*) | |||
| real(kind=sp), | intent(in) | :: | rowcnd | |||
| real(kind=sp), | intent(in) | :: | colcnd | |||
| real(kind=sp), | intent(in) | :: | amax | |||
| character, | intent(out) | :: | equed |
DLAQGB equilibrates a general M by N band matrix A with KL subdiagonals and KU superdiagonals using the row and scaling factors in the vectors R and C.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | kl | |||
| integer(kind=ilp), | intent(in) | :: | ku | |||
| real(kind=dp), | intent(inout) | :: | ab(ldab,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldab | |||
| real(kind=dp), | intent(in) | :: | r(*) | |||
| real(kind=dp), | intent(in) | :: | c(*) | |||
| real(kind=dp), | intent(in) | :: | rowcnd | |||
| real(kind=dp), | intent(in) | :: | colcnd | |||
| real(kind=dp), | intent(in) | :: | amax | |||
| character, | intent(out) | :: | equed |
SLAQGB equilibrates a general M by N band matrix A with KL subdiagonals and KU superdiagonals using the row and scaling factors in the vectors R and C.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | kl | |||
| integer(kind=ilp), | intent(in) | :: | ku | |||
| real(kind=sp), | intent(inout) | :: | ab(ldab,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldab | |||
| real(kind=sp), | intent(in) | :: | r(*) | |||
| real(kind=sp), | intent(in) | :: | c(*) | |||
| real(kind=sp), | intent(in) | :: | rowcnd | |||
| real(kind=sp), | intent(in) | :: | colcnd | |||
| real(kind=sp), | intent(in) | :: | amax | |||
| character, | intent(out) | :: | equed |
ZLAQGB equilibrates a general M by N band matrix A with KL subdiagonals and KU superdiagonals using the row and scaling factors in the vectors R and C.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | kl | |||
| integer(kind=ilp), | intent(in) | :: | ku | |||
| complex(kind=dp), | intent(inout) | :: | ab(ldab,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldab | |||
| real(kind=dp), | intent(in) | :: | r(*) | |||
| real(kind=dp), | intent(in) | :: | c(*) | |||
| real(kind=dp), | intent(in) | :: | rowcnd | |||
| real(kind=dp), | intent(in) | :: | colcnd | |||
| real(kind=dp), | intent(in) | :: | amax | |||
| character, | intent(out) | :: | equed |
LAQGE equilibrates a general M by N matrix A using the row and column scaling factors in the vectors R and C.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=sp), | intent(in) | :: | r(*) | |||
| real(kind=sp), | intent(in) | :: | c(*) | |||
| real(kind=sp), | intent(in) | :: | rowcnd | |||
| real(kind=sp), | intent(in) | :: | colcnd | |||
| real(kind=sp), | intent(in) | :: | amax | |||
| character, | intent(out) | :: | equed |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=dp), | intent(in) | :: | r(*) | |||
| real(kind=dp), | intent(in) | :: | c(*) | |||
| real(kind=dp), | intent(in) | :: | rowcnd | |||
| real(kind=dp), | intent(in) | :: | colcnd | |||
| real(kind=dp), | intent(in) | :: | amax | |||
| character, | intent(out) | :: | equed |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=sp), | intent(in) | :: | r(*) | |||
| real(kind=sp), | intent(in) | :: | c(*) | |||
| real(kind=sp), | intent(in) | :: | rowcnd | |||
| real(kind=sp), | intent(in) | :: | colcnd | |||
| real(kind=sp), | intent(in) | :: | amax | |||
| character, | intent(out) | :: | equed |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=dp), | intent(in) | :: | r(*) | |||
| real(kind=dp), | intent(in) | :: | c(*) | |||
| real(kind=dp), | intent(in) | :: | rowcnd | |||
| real(kind=dp), | intent(in) | :: | colcnd | |||
| real(kind=dp), | intent(in) | :: | amax | |||
| character, | intent(out) | :: | equed |
CLAQGE equilibrates a general M by N matrix A using the row and column scaling factors in the vectors R and C.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=sp), | intent(in) | :: | r(*) | |||
| real(kind=sp), | intent(in) | :: | c(*) | |||
| real(kind=sp), | intent(in) | :: | rowcnd | |||
| real(kind=sp), | intent(in) | :: | colcnd | |||
| real(kind=sp), | intent(in) | :: | amax | |||
| character, | intent(out) | :: | equed |
DLAQGE equilibrates a general M by N matrix A using the row and column scaling factors in the vectors R and C.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=dp), | intent(in) | :: | r(*) | |||
| real(kind=dp), | intent(in) | :: | c(*) | |||
| real(kind=dp), | intent(in) | :: | rowcnd | |||
| real(kind=dp), | intent(in) | :: | colcnd | |||
| real(kind=dp), | intent(in) | :: | amax | |||
| character, | intent(out) | :: | equed |
SLAQGE equilibrates a general M by N matrix A using the row and column scaling factors in the vectors R and C.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=sp), | intent(in) | :: | r(*) | |||
| real(kind=sp), | intent(in) | :: | c(*) | |||
| real(kind=sp), | intent(in) | :: | rowcnd | |||
| real(kind=sp), | intent(in) | :: | colcnd | |||
| real(kind=sp), | intent(in) | :: | amax | |||
| character, | intent(out) | :: | equed |
ZLAQGE equilibrates a general M by N matrix A using the row and column scaling factors in the vectors R and C.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=dp), | intent(in) | :: | r(*) | |||
| real(kind=dp), | intent(in) | :: | c(*) | |||
| real(kind=dp), | intent(in) | :: | rowcnd | |||
| real(kind=dp), | intent(in) | :: | colcnd | |||
| real(kind=dp), | intent(in) | :: | amax | |||
| character, | intent(out) | :: | equed |
LAQHB equilibrates an Hermitian band matrix A using the scaling factors in the vector S.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | kd | |||
| complex(kind=sp), | intent(inout) | :: | ab(ldab,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldab | |||
| real(kind=sp), | intent(out) | :: | s(*) | |||
| real(kind=sp), | intent(in) | :: | scond | |||
| real(kind=sp), | intent(in) | :: | amax | |||
| character, | intent(out) | :: | equed |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | kd | |||
| complex(kind=dp), | intent(inout) | :: | ab(ldab,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldab | |||
| real(kind=dp), | intent(out) | :: | s(*) | |||
| real(kind=dp), | intent(in) | :: | scond | |||
| real(kind=dp), | intent(in) | :: | amax | |||
| character, | intent(out) | :: | equed |
CLAQHB equilibrates an Hermitian band matrix A using the scaling factors in the vector S.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | kd | |||
| complex(kind=sp), | intent(inout) | :: | ab(ldab,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldab | |||
| real(kind=sp), | intent(out) | :: | s(*) | |||
| real(kind=sp), | intent(in) | :: | scond | |||
| real(kind=sp), | intent(in) | :: | amax | |||
| character, | intent(out) | :: | equed |
ZLAQHB equilibrates a Hermitian band matrix A using the scaling factors in the vector S.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | kd | |||
| complex(kind=dp), | intent(inout) | :: | ab(ldab,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldab | |||
| real(kind=dp), | intent(out) | :: | s(*) | |||
| real(kind=dp), | intent(in) | :: | scond | |||
| real(kind=dp), | intent(in) | :: | amax | |||
| character, | intent(out) | :: | equed |
LAQHE equilibrates a Hermitian matrix A using the scaling factors in the vector S.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=sp), | intent(in) | :: | s(*) | |||
| real(kind=sp), | intent(in) | :: | scond | |||
| real(kind=sp), | intent(in) | :: | amax | |||
| character, | intent(out) | :: | equed |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=dp), | intent(in) | :: | s(*) | |||
| real(kind=dp), | intent(in) | :: | scond | |||
| real(kind=dp), | intent(in) | :: | amax | |||
| character, | intent(out) | :: | equed |
CLAQHE equilibrates a Hermitian matrix A using the scaling factors in the vector S.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=sp), | intent(in) | :: | s(*) | |||
| real(kind=sp), | intent(in) | :: | scond | |||
| real(kind=sp), | intent(in) | :: | amax | |||
| character, | intent(out) | :: | equed |
ZLAQHE equilibrates a Hermitian matrix A using the scaling factors in the vector S.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=dp), | intent(in) | :: | s(*) | |||
| real(kind=dp), | intent(in) | :: | scond | |||
| real(kind=dp), | intent(in) | :: | amax | |||
| character, | intent(out) | :: | equed |
LAQHP equilibrates a Hermitian matrix A using the scaling factors in the vector S.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=sp), | intent(inout) | :: | ap(*) | |||
| real(kind=sp), | intent(in) | :: | s(*) | |||
| real(kind=sp), | intent(in) | :: | scond | |||
| real(kind=sp), | intent(in) | :: | amax | |||
| character, | intent(out) | :: | equed |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=dp), | intent(inout) | :: | ap(*) | |||
| real(kind=dp), | intent(in) | :: | s(*) | |||
| real(kind=dp), | intent(in) | :: | scond | |||
| real(kind=dp), | intent(in) | :: | amax | |||
| character, | intent(out) | :: | equed |
CLAQHP equilibrates a Hermitian matrix A using the scaling factors in the vector S.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=sp), | intent(inout) | :: | ap(*) | |||
| real(kind=sp), | intent(in) | :: | s(*) | |||
| real(kind=sp), | intent(in) | :: | scond | |||
| real(kind=sp), | intent(in) | :: | amax | |||
| character, | intent(out) | :: | equed |
ZLAQHP equilibrates a Hermitian matrix A using the scaling factors in the vector S.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=dp), | intent(inout) | :: | ap(*) | |||
| real(kind=dp), | intent(in) | :: | s(*) | |||
| real(kind=dp), | intent(in) | :: | scond | |||
| real(kind=dp), | intent(in) | :: | amax | |||
| character, | intent(out) | :: | equed |
LAQPS computes a step of QR factorization with column pivoting of a complex M-by-N matrix A by using Blas-3. It tries to factorize NB columns from A starting from the row OFFSET+1, and updates all of the matrix with Blas-3 xGEMM. In some cases, due to catastrophic cancellations, it cannot factorize NB columns. Hence, the actual number of factorized columns is returned in KB. Block A(1:OFFSET,1:N) is accordingly pivoted, but not factorized.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | offset | |||
| integer(kind=ilp), | intent(in) | :: | nb | |||
| integer(kind=ilp), | intent(out) | :: | kb | |||
| complex(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| integer(kind=ilp), | intent(inout) | :: | jpvt(*) | |||
| complex(kind=sp), | intent(out) | :: | tau(*) | |||
| real(kind=sp), | intent(inout) | :: | vn1(*) | |||
| real(kind=sp), | intent(inout) | :: | vn2(*) | |||
| complex(kind=sp), | intent(inout) | :: | auxv(*) | |||
| complex(kind=sp), | intent(inout) | :: | f(ldf,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldf |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | offset | |||
| integer(kind=ilp), | intent(in) | :: | nb | |||
| integer(kind=ilp), | intent(out) | :: | kb | |||
| real(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| integer(kind=ilp), | intent(inout) | :: | jpvt(*) | |||
| real(kind=dp), | intent(out) | :: | tau(*) | |||
| real(kind=dp), | intent(inout) | :: | vn1(*) | |||
| real(kind=dp), | intent(inout) | :: | vn2(*) | |||
| real(kind=dp), | intent(inout) | :: | auxv(*) | |||
| real(kind=dp), | intent(inout) | :: | f(ldf,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldf |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | offset | |||
| integer(kind=ilp), | intent(in) | :: | nb | |||
| integer(kind=ilp), | intent(out) | :: | kb | |||
| real(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| integer(kind=ilp), | intent(inout) | :: | jpvt(*) | |||
| real(kind=sp), | intent(out) | :: | tau(*) | |||
| real(kind=sp), | intent(inout) | :: | vn1(*) | |||
| real(kind=sp), | intent(inout) | :: | vn2(*) | |||
| real(kind=sp), | intent(inout) | :: | auxv(*) | |||
| real(kind=sp), | intent(inout) | :: | f(ldf,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldf |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | offset | |||
| integer(kind=ilp), | intent(in) | :: | nb | |||
| integer(kind=ilp), | intent(out) | :: | kb | |||
| complex(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| integer(kind=ilp), | intent(inout) | :: | jpvt(*) | |||
| complex(kind=dp), | intent(out) | :: | tau(*) | |||
| real(kind=dp), | intent(inout) | :: | vn1(*) | |||
| real(kind=dp), | intent(inout) | :: | vn2(*) | |||
| complex(kind=dp), | intent(inout) | :: | auxv(*) | |||
| complex(kind=dp), | intent(inout) | :: | f(ldf,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldf |
CLAQPS computes a step of QR factorization with column pivoting of a complex M-by-N matrix A by using Blas-3. It tries to factorize NB columns from A starting from the row OFFSET+1, and updates all of the matrix with Blas-3 xGEMM. In some cases, due to catastrophic cancellations, it cannot factorize NB columns. Hence, the actual number of factorized columns is returned in KB. Block A(1:OFFSET,1:N) is accordingly pivoted, but not factorized.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | offset | |||
| integer(kind=ilp), | intent(in) | :: | nb | |||
| integer(kind=ilp), | intent(out) | :: | kb | |||
| complex(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| integer(kind=ilp), | intent(inout) | :: | jpvt(*) | |||
| complex(kind=sp), | intent(out) | :: | tau(*) | |||
| real(kind=sp), | intent(inout) | :: | vn1(*) | |||
| real(kind=sp), | intent(inout) | :: | vn2(*) | |||
| complex(kind=sp), | intent(inout) | :: | auxv(*) | |||
| complex(kind=sp), | intent(inout) | :: | f(ldf,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldf |
DLAQPS computes a step of QR factorization with column pivoting of a real M-by-N matrix A by using Blas-3. It tries to factorize NB columns from A starting from the row OFFSET+1, and updates all of the matrix with Blas-3 xGEMM. In some cases, due to catastrophic cancellations, it cannot factorize NB columns. Hence, the actual number of factorized columns is returned in KB. Block A(1:OFFSET,1:N) is accordingly pivoted, but not factorized.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | offset | |||
| integer(kind=ilp), | intent(in) | :: | nb | |||
| integer(kind=ilp), | intent(out) | :: | kb | |||
| real(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| integer(kind=ilp), | intent(inout) | :: | jpvt(*) | |||
| real(kind=dp), | intent(out) | :: | tau(*) | |||
| real(kind=dp), | intent(inout) | :: | vn1(*) | |||
| real(kind=dp), | intent(inout) | :: | vn2(*) | |||
| real(kind=dp), | intent(inout) | :: | auxv(*) | |||
| real(kind=dp), | intent(inout) | :: | f(ldf,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldf |
SLAQPS computes a step of QR factorization with column pivoting of a real M-by-N matrix A by using Blas-3. It tries to factorize NB columns from A starting from the row OFFSET+1, and updates all of the matrix with Blas-3 xGEMM. In some cases, due to catastrophic cancellations, it cannot factorize NB columns. Hence, the actual number of factorized columns is returned in KB. Block A(1:OFFSET,1:N) is accordingly pivoted, but not factorized.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | offset | |||
| integer(kind=ilp), | intent(in) | :: | nb | |||
| integer(kind=ilp), | intent(out) | :: | kb | |||
| real(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| integer(kind=ilp), | intent(inout) | :: | jpvt(*) | |||
| real(kind=sp), | intent(out) | :: | tau(*) | |||
| real(kind=sp), | intent(inout) | :: | vn1(*) | |||
| real(kind=sp), | intent(inout) | :: | vn2(*) | |||
| real(kind=sp), | intent(inout) | :: | auxv(*) | |||
| real(kind=sp), | intent(inout) | :: | f(ldf,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldf |
ZLAQPS computes a step of QR factorization with column pivoting of a complex M-by-N matrix A by using Blas-3. It tries to factorize NB columns from A starting from the row OFFSET+1, and updates all of the matrix with Blas-3 xGEMM. In some cases, due to catastrophic cancellations, it cannot factorize NB columns. Hence, the actual number of factorized columns is returned in KB. Block A(1:OFFSET,1:N) is accordingly pivoted, but not factorized.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | offset | |||
| integer(kind=ilp), | intent(in) | :: | nb | |||
| integer(kind=ilp), | intent(out) | :: | kb | |||
| complex(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| integer(kind=ilp), | intent(inout) | :: | jpvt(*) | |||
| complex(kind=dp), | intent(out) | :: | tau(*) | |||
| real(kind=dp), | intent(inout) | :: | vn1(*) | |||
| real(kind=dp), | intent(inout) | :: | vn2(*) | |||
| complex(kind=dp), | intent(inout) | :: | auxv(*) | |||
| complex(kind=dp), | intent(inout) | :: | f(ldf,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldf |
LAQR0 computes the eigenvalues of a Hessenberg matrix H and, optionally, the matrices T and Z from the Schur decomposition H = Z T ZH, where T is an upper triangular matrix (the Schur form), and Z is the unitary matrix of Schur vectors. Optionally Z may be postmultiplied into an input unitary matrix Q so that this routine can give the Schur factorization of a matrix A which has been reduced to the Hessenberg form H by the unitary matrix Q: A = QHQH = (QZ)H(QZ)**H.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| logical(kind=lk), | intent(in) | :: | wantt | |||
| logical(kind=lk), | intent(in) | :: | wantz | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | ilo | |||
| integer(kind=ilp), | intent(in) | :: | ihi | |||
| complex(kind=sp), | intent(inout) | :: | h(ldh,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldh | |||
| complex(kind=sp), | intent(out) | :: | w(*) | |||
| integer(kind=ilp), | intent(in) | :: | iloz | |||
| integer(kind=ilp), | intent(in) | :: | ihiz | |||
| complex(kind=sp), | intent(inout) | :: | z(ldz,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldz | |||
| complex(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| logical(kind=lk), | intent(in) | :: | wantt | |||
| logical(kind=lk), | intent(in) | :: | wantz | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | ilo | |||
| integer(kind=ilp), | intent(in) | :: | ihi | |||
| real(kind=dp), | intent(inout) | :: | h(ldh,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldh | |||
| real(kind=dp), | intent(out) | :: | wr(*) | |||
| real(kind=dp), | intent(out) | :: | wi(*) | |||
| integer(kind=ilp), | intent(in) | :: | iloz | |||
| integer(kind=ilp), | intent(in) | :: | ihiz | |||
| real(kind=dp), | intent(inout) | :: | z(ldz,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldz | |||
| real(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| logical(kind=lk), | intent(in) | :: | wantt | |||
| logical(kind=lk), | intent(in) | :: | wantz | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | ilo | |||
| integer(kind=ilp), | intent(in) | :: | ihi | |||
| real(kind=sp), | intent(inout) | :: | h(ldh,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldh | |||
| real(kind=sp), | intent(out) | :: | wr(*) | |||
| real(kind=sp), | intent(out) | :: | wi(*) | |||
| integer(kind=ilp), | intent(in) | :: | iloz | |||
| integer(kind=ilp), | intent(in) | :: | ihiz | |||
| real(kind=sp), | intent(inout) | :: | z(ldz,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldz | |||
| real(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| logical(kind=lk), | intent(in) | :: | wantt | |||
| logical(kind=lk), | intent(in) | :: | wantz | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | ilo | |||
| integer(kind=ilp), | intent(in) | :: | ihi | |||
| complex(kind=dp), | intent(inout) | :: | h(ldh,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldh | |||
| complex(kind=dp), | intent(out) | :: | w(*) | |||
| integer(kind=ilp), | intent(in) | :: | iloz | |||
| integer(kind=ilp), | intent(in) | :: | ihiz | |||
| complex(kind=dp), | intent(inout) | :: | z(ldz,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldz | |||
| complex(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
CLAQR0 computes the eigenvalues of a Hessenberg matrix H and, optionally, the matrices T and Z from the Schur decomposition H = Z T ZH, where T is an upper triangular matrix (the Schur form), and Z is the unitary matrix of Schur vectors. Optionally Z may be postmultiplied into an input unitary matrix Q so that this routine can give the Schur factorization of a matrix A which has been reduced to the Hessenberg form H by the unitary matrix Q: A = QHQH = (QZ)H(QZ)**H.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| logical(kind=lk), | intent(in) | :: | wantt | |||
| logical(kind=lk), | intent(in) | :: | wantz | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | ilo | |||
| integer(kind=ilp), | intent(in) | :: | ihi | |||
| complex(kind=sp), | intent(inout) | :: | h(ldh,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldh | |||
| complex(kind=sp), | intent(out) | :: | w(*) | |||
| integer(kind=ilp), | intent(in) | :: | iloz | |||
| integer(kind=ilp), | intent(in) | :: | ihiz | |||
| complex(kind=sp), | intent(inout) | :: | z(ldz,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldz | |||
| complex(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
DLAQR0 computes the eigenvalues of a Hessenberg matrix H and, optionally, the matrices T and Z from the Schur decomposition H = Z T ZT, where T is an upper quasi-triangular matrix (the Schur form), and Z is the orthogonal matrix of Schur vectors. Optionally Z may be postmultiplied into an input orthogonal matrix Q so that this routine can give the Schur factorization of a matrix A which has been reduced to the Hessenberg form H by the orthogonal matrix Q: A = QHQT = (QZ)T(QZ)**T.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| logical(kind=lk), | intent(in) | :: | wantt | |||
| logical(kind=lk), | intent(in) | :: | wantz | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | ilo | |||
| integer(kind=ilp), | intent(in) | :: | ihi | |||
| real(kind=dp), | intent(inout) | :: | h(ldh,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldh | |||
| real(kind=dp), | intent(out) | :: | wr(*) | |||
| real(kind=dp), | intent(out) | :: | wi(*) | |||
| integer(kind=ilp), | intent(in) | :: | iloz | |||
| integer(kind=ilp), | intent(in) | :: | ihiz | |||
| real(kind=dp), | intent(inout) | :: | z(ldz,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldz | |||
| real(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
SLAQR0 computes the eigenvalues of a Hessenberg matrix H and, optionally, the matrices T and Z from the Schur decomposition H = Z T ZT, where T is an upper quasi-triangular matrix (the Schur form), and Z is the orthogonal matrix of Schur vectors. Optionally Z may be postmultiplied into an input orthogonal matrix Q so that this routine can give the Schur factorization of a matrix A which has been reduced to the Hessenberg form H by the orthogonal matrix Q: A = QHQT = (QZ)T(QZ)**T.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| logical(kind=lk), | intent(in) | :: | wantt | |||
| logical(kind=lk), | intent(in) | :: | wantz | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | ilo | |||
| integer(kind=ilp), | intent(in) | :: | ihi | |||
| real(kind=sp), | intent(inout) | :: | h(ldh,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldh | |||
| real(kind=sp), | intent(out) | :: | wr(*) | |||
| real(kind=sp), | intent(out) | :: | wi(*) | |||
| integer(kind=ilp), | intent(in) | :: | iloz | |||
| integer(kind=ilp), | intent(in) | :: | ihiz | |||
| real(kind=sp), | intent(inout) | :: | z(ldz,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldz | |||
| real(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
ZLAQR0 computes the eigenvalues of a Hessenberg matrix H and, optionally, the matrices T and Z from the Schur decomposition H = Z T ZH, where T is an upper triangular matrix (the Schur form), and Z is the unitary matrix of Schur vectors. Optionally Z may be postmultiplied into an input unitary matrix Q so that this routine can give the Schur factorization of a matrix A which has been reduced to the Hessenberg form H by the unitary matrix Q: A = QHQH = (QZ)H(QZ)**H.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| logical(kind=lk), | intent(in) | :: | wantt | |||
| logical(kind=lk), | intent(in) | :: | wantz | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | ilo | |||
| integer(kind=ilp), | intent(in) | :: | ihi | |||
| complex(kind=dp), | intent(inout) | :: | h(ldh,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldh | |||
| complex(kind=dp), | intent(out) | :: | w(*) | |||
| integer(kind=ilp), | intent(in) | :: | iloz | |||
| integer(kind=ilp), | intent(in) | :: | ihiz | |||
| complex(kind=dp), | intent(inout) | :: | z(ldz,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldz | |||
| complex(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
Given a 2-by-2 or 3-by-3 matrix H, LAQR1: sets v to a scalar multiple of the first column of the product () K = (H - s1I)(H - s2I) scaling to avoid overflows and most underflows. This is useful for starting double implicit shift bulges in the QR algorithm.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=sp), | intent(in) | :: | h(ldh,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldh | |||
| complex(kind=sp), | intent(in) | :: | s1 | |||
| complex(kind=sp), | intent(in) | :: | s2 | |||
| complex(kind=sp), | intent(out) | :: | v(*) |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=dp), | intent(in) | :: | h(ldh,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldh | |||
| real(kind=dp), | intent(in) | :: | sr1 | |||
| real(kind=dp), | intent(in) | :: | si1 | |||
| real(kind=dp), | intent(in) | :: | sr2 | |||
| real(kind=dp), | intent(in) | :: | si2 | |||
| real(kind=dp), | intent(out) | :: | v(*) |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=sp), | intent(in) | :: | h(ldh,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldh | |||
| real(kind=sp), | intent(in) | :: | sr1 | |||
| real(kind=sp), | intent(in) | :: | si1 | |||
| real(kind=sp), | intent(in) | :: | sr2 | |||
| real(kind=sp), | intent(in) | :: | si2 | |||
| real(kind=sp), | intent(out) | :: | v(*) |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=dp), | intent(in) | :: | h(ldh,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldh | |||
| complex(kind=dp), | intent(in) | :: | s1 | |||
| complex(kind=dp), | intent(in) | :: | s2 | |||
| complex(kind=dp), | intent(out) | :: | v(*) |
Given a 2-by-2 or 3-by-3 matrix H, CLAQR1: sets v to a scalar multiple of the first column of the product () K = (H - s1I)(H - s2I) scaling to avoid overflows and most underflows. This is useful for starting double implicit shift bulges in the QR algorithm.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=sp), | intent(in) | :: | h(ldh,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldh | |||
| complex(kind=sp), | intent(in) | :: | s1 | |||
| complex(kind=sp), | intent(in) | :: | s2 | |||
| complex(kind=sp), | intent(out) | :: | v(*) |
Given a 2-by-2 or 3-by-3 matrix H, DLAQR1: sets v to a scalar multiple of the first column of the product () K = (H - (sr1 + isi1)I)(H - (sr2 + isi2)I) scaling to avoid overflows and most underflows. It is assumed that either 1) sr1 = sr2 and si1 = -si2 or 2) si1 = si2 = 0. This is useful for starting double implicit shift bulges in the QR algorithm.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=dp), | intent(in) | :: | h(ldh,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldh | |||
| real(kind=dp), | intent(in) | :: | sr1 | |||
| real(kind=dp), | intent(in) | :: | si1 | |||
| real(kind=dp), | intent(in) | :: | sr2 | |||
| real(kind=dp), | intent(in) | :: | si2 | |||
| real(kind=dp), | intent(out) | :: | v(*) |
Given a 2-by-2 or 3-by-3 matrix H, SLAQR1: sets v to a scalar multiple of the first column of the product () K = (H - (sr1 + isi1)I)(H - (sr2 + isi2)I) scaling to avoid overflows and most underflows. It is assumed that either 1) sr1 = sr2 and si1 = -si2 or 2) si1 = si2 = 0. This is useful for starting double implicit shift bulges in the QR algorithm.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=sp), | intent(in) | :: | h(ldh,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldh | |||
| real(kind=sp), | intent(in) | :: | sr1 | |||
| real(kind=sp), | intent(in) | :: | si1 | |||
| real(kind=sp), | intent(in) | :: | sr2 | |||
| real(kind=sp), | intent(in) | :: | si2 | |||
| real(kind=sp), | intent(out) | :: | v(*) |
Given a 2-by-2 or 3-by-3 matrix H, ZLAQR1: sets v to a scalar multiple of the first column of the product () K = (H - s1I)(H - s2I) scaling to avoid overflows and most underflows. This is useful for starting double implicit shift bulges in the QR algorithm.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=dp), | intent(in) | :: | h(ldh,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldh | |||
| complex(kind=dp), | intent(in) | :: | s1 | |||
| complex(kind=dp), | intent(in) | :: | s2 | |||
| complex(kind=dp), | intent(out) | :: | v(*) |
LAQR4 implements one level of recursion for CLAQR0. It is a complete implementation of the small bulge multi-shift QR algorithm. It may be called by CLAQR0 and, for large enough deflation window size, it may be called by CLAQR3. This subroutine is identical to CLAQR0 except that it calls CLAQR2 instead of CLAQR3. LAQR4 computes the eigenvalues of a Hessenberg matrix H and, optionally, the matrices T and Z from the Schur decomposition H = Z T ZH, where T is an upper triangular matrix (the Schur form), and Z is the unitary matrix of Schur vectors. Optionally Z may be postmultiplied into an input unitary matrix Q so that this routine can give the Schur factorization of a matrix A which has been reduced to the Hessenberg form H by the unitary matrix Q: A = QHQH = (QZ)H(QZ)**H.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| logical(kind=lk), | intent(in) | :: | wantt | |||
| logical(kind=lk), | intent(in) | :: | wantz | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | ilo | |||
| integer(kind=ilp), | intent(in) | :: | ihi | |||
| complex(kind=sp), | intent(inout) | :: | h(ldh,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldh | |||
| complex(kind=sp), | intent(out) | :: | w(*) | |||
| integer(kind=ilp), | intent(in) | :: | iloz | |||
| integer(kind=ilp), | intent(in) | :: | ihiz | |||
| complex(kind=sp), | intent(inout) | :: | z(ldz,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldz | |||
| complex(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| logical(kind=lk), | intent(in) | :: | wantt | |||
| logical(kind=lk), | intent(in) | :: | wantz | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | ilo | |||
| integer(kind=ilp), | intent(in) | :: | ihi | |||
| real(kind=dp), | intent(inout) | :: | h(ldh,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldh | |||
| real(kind=dp), | intent(out) | :: | wr(*) | |||
| real(kind=dp), | intent(out) | :: | wi(*) | |||
| integer(kind=ilp), | intent(in) | :: | iloz | |||
| integer(kind=ilp), | intent(in) | :: | ihiz | |||
| real(kind=dp), | intent(inout) | :: | z(ldz,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldz | |||
| real(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| logical(kind=lk), | intent(in) | :: | wantt | |||
| logical(kind=lk), | intent(in) | :: | wantz | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | ilo | |||
| integer(kind=ilp), | intent(in) | :: | ihi | |||
| real(kind=sp), | intent(inout) | :: | h(ldh,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldh | |||
| real(kind=sp), | intent(out) | :: | wr(*) | |||
| real(kind=sp), | intent(out) | :: | wi(*) | |||
| integer(kind=ilp), | intent(in) | :: | iloz | |||
| integer(kind=ilp), | intent(in) | :: | ihiz | |||
| real(kind=sp), | intent(inout) | :: | z(ldz,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldz | |||
| real(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| logical(kind=lk), | intent(in) | :: | wantt | |||
| logical(kind=lk), | intent(in) | :: | wantz | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | ilo | |||
| integer(kind=ilp), | intent(in) | :: | ihi | |||
| complex(kind=dp), | intent(inout) | :: | h(ldh,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldh | |||
| complex(kind=dp), | intent(out) | :: | w(*) | |||
| integer(kind=ilp), | intent(in) | :: | iloz | |||
| integer(kind=ilp), | intent(in) | :: | ihiz | |||
| complex(kind=dp), | intent(inout) | :: | z(ldz,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldz | |||
| complex(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
CLAQR4 implements one level of recursion for CLAQR0. It is a complete implementation of the small bulge multi-shift QR algorithm. It may be called by CLAQR0 and, for large enough deflation window size, it may be called by CLAQR3. This subroutine is identical to CLAQR0 except that it calls CLAQR2 instead of CLAQR3. CLAQR4 computes the eigenvalues of a Hessenberg matrix H and, optionally, the matrices T and Z from the Schur decomposition H = Z T ZH, where T is an upper triangular matrix (the Schur form), and Z is the unitary matrix of Schur vectors. Optionally Z may be postmultiplied into an input unitary matrix Q so that this routine can give the Schur factorization of a matrix A which has been reduced to the Hessenberg form H by the unitary matrix Q: A = QHQH = (QZ)H(QZ)**H.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| logical(kind=lk), | intent(in) | :: | wantt | |||
| logical(kind=lk), | intent(in) | :: | wantz | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | ilo | |||
| integer(kind=ilp), | intent(in) | :: | ihi | |||
| complex(kind=sp), | intent(inout) | :: | h(ldh,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldh | |||
| complex(kind=sp), | intent(out) | :: | w(*) | |||
| integer(kind=ilp), | intent(in) | :: | iloz | |||
| integer(kind=ilp), | intent(in) | :: | ihiz | |||
| complex(kind=sp), | intent(inout) | :: | z(ldz,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldz | |||
| complex(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
DLAQR4 implements one level of recursion for DLAQR0. It is a complete implementation of the small bulge multi-shift QR algorithm. It may be called by DLAQR0 and, for large enough deflation window size, it may be called by DLAQR3. This subroutine is identical to DLAQR0 except that it calls DLAQR2 instead of DLAQR3. DLAQR4 computes the eigenvalues of a Hessenberg matrix H and, optionally, the matrices T and Z from the Schur decomposition H = Z T ZT, where T is an upper quasi-triangular matrix (the Schur form), and Z is the orthogonal matrix of Schur vectors. Optionally Z may be postmultiplied into an input orthogonal matrix Q so that this routine can give the Schur factorization of a matrix A which has been reduced to the Hessenberg form H by the orthogonal matrix Q: A = QHQT = (QZ)T(QZ)**T.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| logical(kind=lk), | intent(in) | :: | wantt | |||
| logical(kind=lk), | intent(in) | :: | wantz | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | ilo | |||
| integer(kind=ilp), | intent(in) | :: | ihi | |||
| real(kind=dp), | intent(inout) | :: | h(ldh,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldh | |||
| real(kind=dp), | intent(out) | :: | wr(*) | |||
| real(kind=dp), | intent(out) | :: | wi(*) | |||
| integer(kind=ilp), | intent(in) | :: | iloz | |||
| integer(kind=ilp), | intent(in) | :: | ihiz | |||
| real(kind=dp), | intent(inout) | :: | z(ldz,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldz | |||
| real(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
SLAQR4 implements one level of recursion for SLAQR0. It is a complete implementation of the small bulge multi-shift QR algorithm. It may be called by SLAQR0 and, for large enough deflation window size, it may be called by SLAQR3. This subroutine is identical to SLAQR0 except that it calls SLAQR2 instead of SLAQR3. SLAQR4 computes the eigenvalues of a Hessenberg matrix H and, optionally, the matrices T and Z from the Schur decomposition H = Z T ZT, where T is an upper quasi-triangular matrix (the Schur form), and Z is the orthogonal matrix of Schur vectors. Optionally Z may be postmultiplied into an input orthogonal matrix Q so that this routine can give the Schur factorization of a matrix A which has been reduced to the Hessenberg form H by the orthogonal matrix Q: A = QHQT = (QZ)T(QZ)**T.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| logical(kind=lk), | intent(in) | :: | wantt | |||
| logical(kind=lk), | intent(in) | :: | wantz | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | ilo | |||
| integer(kind=ilp), | intent(in) | :: | ihi | |||
| real(kind=sp), | intent(inout) | :: | h(ldh,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldh | |||
| real(kind=sp), | intent(out) | :: | wr(*) | |||
| real(kind=sp), | intent(out) | :: | wi(*) | |||
| integer(kind=ilp), | intent(in) | :: | iloz | |||
| integer(kind=ilp), | intent(in) | :: | ihiz | |||
| real(kind=sp), | intent(inout) | :: | z(ldz,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldz | |||
| real(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
ZLAQR4 implements one level of recursion for ZLAQR0. It is a complete implementation of the small bulge multi-shift QR algorithm. It may be called by ZLAQR0 and, for large enough deflation window size, it may be called by ZLAQR3. This subroutine is identical to ZLAQR0 except that it calls ZLAQR2 instead of ZLAQR3. ZLAQR4 computes the eigenvalues of a Hessenberg matrix H and, optionally, the matrices T and Z from the Schur decomposition H = Z T ZH, where T is an upper triangular matrix (the Schur form), and Z is the unitary matrix of Schur vectors. Optionally Z may be postmultiplied into an input unitary matrix Q so that this routine can give the Schur factorization of a matrix A which has been reduced to the Hessenberg form H by the unitary matrix Q: A = QHQH = (QZ)H(QZ)**H.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| logical(kind=lk), | intent(in) | :: | wantt | |||
| logical(kind=lk), | intent(in) | :: | wantz | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | ilo | |||
| integer(kind=ilp), | intent(in) | :: | ihi | |||
| complex(kind=dp), | intent(inout) | :: | h(ldh,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldh | |||
| complex(kind=dp), | intent(out) | :: | w(*) | |||
| integer(kind=ilp), | intent(in) | :: | iloz | |||
| integer(kind=ilp), | intent(in) | :: | ihiz | |||
| complex(kind=dp), | intent(inout) | :: | z(ldz,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldz | |||
| complex(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
LAQR5 called by CLAQR0 performs a single small-bulge multi-shift QR sweep.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| logical(kind=lk), | intent(in) | :: | wantt | |||
| logical(kind=lk), | intent(in) | :: | wantz | |||
| integer(kind=ilp), | intent(in) | :: | kacc22 | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | ktop | |||
| integer(kind=ilp), | intent(in) | :: | kbot | |||
| integer(kind=ilp), | intent(in) | :: | nshfts | |||
| complex(kind=sp), | intent(inout) | :: | s(*) | |||
| complex(kind=sp), | intent(inout) | :: | h(ldh,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldh | |||
| integer(kind=ilp), | intent(in) | :: | iloz | |||
| integer(kind=ilp), | intent(in) | :: | ihiz | |||
| complex(kind=sp), | intent(inout) | :: | z(ldz,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldz | |||
| complex(kind=sp), | intent(out) | :: | v(ldv,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldv | |||
| complex(kind=sp), | intent(out) | :: | u(ldu,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldu | |||
| integer(kind=ilp), | intent(in) | :: | nv | |||
| complex(kind=sp), | intent(out) | :: | wv(ldwv,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldwv | |||
| integer(kind=ilp), | intent(in) | :: | nh | |||
| complex(kind=sp), | intent(out) | :: | wh(ldwh,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldwh |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| logical(kind=lk), | intent(in) | :: | wantt | |||
| logical(kind=lk), | intent(in) | :: | wantz | |||
| integer(kind=ilp), | intent(in) | :: | kacc22 | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | ktop | |||
| integer(kind=ilp), | intent(in) | :: | kbot | |||
| integer(kind=ilp), | intent(in) | :: | nshfts | |||
| real(kind=dp), | intent(inout) | :: | sr(*) | |||
| real(kind=dp), | intent(inout) | :: | si(*) | |||
| real(kind=dp), | intent(inout) | :: | h(ldh,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldh | |||
| integer(kind=ilp), | intent(in) | :: | iloz | |||
| integer(kind=ilp), | intent(in) | :: | ihiz | |||
| real(kind=dp), | intent(inout) | :: | z(ldz,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldz | |||
| real(kind=dp), | intent(out) | :: | v(ldv,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldv | |||
| real(kind=dp), | intent(out) | :: | u(ldu,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldu | |||
| integer(kind=ilp), | intent(in) | :: | nv | |||
| real(kind=dp), | intent(out) | :: | wv(ldwv,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldwv | |||
| integer(kind=ilp), | intent(in) | :: | nh | |||
| real(kind=dp), | intent(out) | :: | wh(ldwh,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldwh |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| logical(kind=lk), | intent(in) | :: | wantt | |||
| logical(kind=lk), | intent(in) | :: | wantz | |||
| integer(kind=ilp), | intent(in) | :: | kacc22 | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | ktop | |||
| integer(kind=ilp), | intent(in) | :: | kbot | |||
| integer(kind=ilp), | intent(in) | :: | nshfts | |||
| real(kind=sp), | intent(inout) | :: | sr(*) | |||
| real(kind=sp), | intent(inout) | :: | si(*) | |||
| real(kind=sp), | intent(inout) | :: | h(ldh,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldh | |||
| integer(kind=ilp), | intent(in) | :: | iloz | |||
| integer(kind=ilp), | intent(in) | :: | ihiz | |||
| real(kind=sp), | intent(inout) | :: | z(ldz,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldz | |||
| real(kind=sp), | intent(out) | :: | v(ldv,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldv | |||
| real(kind=sp), | intent(out) | :: | u(ldu,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldu | |||
| integer(kind=ilp), | intent(in) | :: | nv | |||
| real(kind=sp), | intent(out) | :: | wv(ldwv,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldwv | |||
| integer(kind=ilp), | intent(in) | :: | nh | |||
| real(kind=sp), | intent(out) | :: | wh(ldwh,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldwh |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| logical(kind=lk), | intent(in) | :: | wantt | |||
| logical(kind=lk), | intent(in) | :: | wantz | |||
| integer(kind=ilp), | intent(in) | :: | kacc22 | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | ktop | |||
| integer(kind=ilp), | intent(in) | :: | kbot | |||
| integer(kind=ilp), | intent(in) | :: | nshfts | |||
| complex(kind=dp), | intent(inout) | :: | s(*) | |||
| complex(kind=dp), | intent(inout) | :: | h(ldh,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldh | |||
| integer(kind=ilp), | intent(in) | :: | iloz | |||
| integer(kind=ilp), | intent(in) | :: | ihiz | |||
| complex(kind=dp), | intent(inout) | :: | z(ldz,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldz | |||
| complex(kind=dp), | intent(out) | :: | v(ldv,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldv | |||
| complex(kind=dp), | intent(out) | :: | u(ldu,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldu | |||
| integer(kind=ilp), | intent(in) | :: | nv | |||
| complex(kind=dp), | intent(out) | :: | wv(ldwv,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldwv | |||
| integer(kind=ilp), | intent(in) | :: | nh | |||
| complex(kind=dp), | intent(out) | :: | wh(ldwh,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldwh |
CLAQR5 called by CLAQR0 performs a single small-bulge multi-shift QR sweep.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| logical(kind=lk), | intent(in) | :: | wantt | |||
| logical(kind=lk), | intent(in) | :: | wantz | |||
| integer(kind=ilp), | intent(in) | :: | kacc22 | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | ktop | |||
| integer(kind=ilp), | intent(in) | :: | kbot | |||
| integer(kind=ilp), | intent(in) | :: | nshfts | |||
| complex(kind=sp), | intent(inout) | :: | s(*) | |||
| complex(kind=sp), | intent(inout) | :: | h(ldh,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldh | |||
| integer(kind=ilp), | intent(in) | :: | iloz | |||
| integer(kind=ilp), | intent(in) | :: | ihiz | |||
| complex(kind=sp), | intent(inout) | :: | z(ldz,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldz | |||
| complex(kind=sp), | intent(out) | :: | v(ldv,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldv | |||
| complex(kind=sp), | intent(out) | :: | u(ldu,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldu | |||
| integer(kind=ilp), | intent(in) | :: | nv | |||
| complex(kind=sp), | intent(out) | :: | wv(ldwv,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldwv | |||
| integer(kind=ilp), | intent(in) | :: | nh | |||
| complex(kind=sp), | intent(out) | :: | wh(ldwh,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldwh |
DLAQR5 , called by DLAQR0, performs a single small-bulge multi-shift QR sweep.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| logical(kind=lk), | intent(in) | :: | wantt | |||
| logical(kind=lk), | intent(in) | :: | wantz | |||
| integer(kind=ilp), | intent(in) | :: | kacc22 | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | ktop | |||
| integer(kind=ilp), | intent(in) | :: | kbot | |||
| integer(kind=ilp), | intent(in) | :: | nshfts | |||
| real(kind=dp), | intent(inout) | :: | sr(*) | |||
| real(kind=dp), | intent(inout) | :: | si(*) | |||
| real(kind=dp), | intent(inout) | :: | h(ldh,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldh | |||
| integer(kind=ilp), | intent(in) | :: | iloz | |||
| integer(kind=ilp), | intent(in) | :: | ihiz | |||
| real(kind=dp), | intent(inout) | :: | z(ldz,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldz | |||
| real(kind=dp), | intent(out) | :: | v(ldv,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldv | |||
| real(kind=dp), | intent(out) | :: | u(ldu,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldu | |||
| integer(kind=ilp), | intent(in) | :: | nv | |||
| real(kind=dp), | intent(out) | :: | wv(ldwv,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldwv | |||
| integer(kind=ilp), | intent(in) | :: | nh | |||
| real(kind=dp), | intent(out) | :: | wh(ldwh,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldwh |
SLAQR5 , called by SLAQR0, performs a single small-bulge multi-shift QR sweep.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| logical(kind=lk), | intent(in) | :: | wantt | |||
| logical(kind=lk), | intent(in) | :: | wantz | |||
| integer(kind=ilp), | intent(in) | :: | kacc22 | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | ktop | |||
| integer(kind=ilp), | intent(in) | :: | kbot | |||
| integer(kind=ilp), | intent(in) | :: | nshfts | |||
| real(kind=sp), | intent(inout) | :: | sr(*) | |||
| real(kind=sp), | intent(inout) | :: | si(*) | |||
| real(kind=sp), | intent(inout) | :: | h(ldh,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldh | |||
| integer(kind=ilp), | intent(in) | :: | iloz | |||
| integer(kind=ilp), | intent(in) | :: | ihiz | |||
| real(kind=sp), | intent(inout) | :: | z(ldz,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldz | |||
| real(kind=sp), | intent(out) | :: | v(ldv,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldv | |||
| real(kind=sp), | intent(out) | :: | u(ldu,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldu | |||
| integer(kind=ilp), | intent(in) | :: | nv | |||
| real(kind=sp), | intent(out) | :: | wv(ldwv,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldwv | |||
| integer(kind=ilp), | intent(in) | :: | nh | |||
| real(kind=sp), | intent(out) | :: | wh(ldwh,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldwh |
ZLAQR5 , called by ZLAQR0, performs a single small-bulge multi-shift QR sweep.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| logical(kind=lk), | intent(in) | :: | wantt | |||
| logical(kind=lk), | intent(in) | :: | wantz | |||
| integer(kind=ilp), | intent(in) | :: | kacc22 | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | ktop | |||
| integer(kind=ilp), | intent(in) | :: | kbot | |||
| integer(kind=ilp), | intent(in) | :: | nshfts | |||
| complex(kind=dp), | intent(inout) | :: | s(*) | |||
| complex(kind=dp), | intent(inout) | :: | h(ldh,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldh | |||
| integer(kind=ilp), | intent(in) | :: | iloz | |||
| integer(kind=ilp), | intent(in) | :: | ihiz | |||
| complex(kind=dp), | intent(inout) | :: | z(ldz,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldz | |||
| complex(kind=dp), | intent(out) | :: | v(ldv,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldv | |||
| complex(kind=dp), | intent(out) | :: | u(ldu,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldu | |||
| integer(kind=ilp), | intent(in) | :: | nv | |||
| complex(kind=dp), | intent(out) | :: | wv(ldwv,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldwv | |||
| integer(kind=ilp), | intent(in) | :: | nh | |||
| complex(kind=dp), | intent(out) | :: | wh(ldwh,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldwh |
LAQSB equilibrates a symmetric band matrix A using the scaling factors in the vector S.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | kd | |||
| complex(kind=sp), | intent(inout) | :: | ab(ldab,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldab | |||
| real(kind=sp), | intent(in) | :: | s(*) | |||
| real(kind=sp), | intent(in) | :: | scond | |||
| real(kind=sp), | intent(in) | :: | amax | |||
| character, | intent(out) | :: | equed |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | kd | |||
| real(kind=dp), | intent(inout) | :: | ab(ldab,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldab | |||
| real(kind=dp), | intent(in) | :: | s(*) | |||
| real(kind=dp), | intent(in) | :: | scond | |||
| real(kind=dp), | intent(in) | :: | amax | |||
| character, | intent(out) | :: | equed |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | kd | |||
| real(kind=sp), | intent(inout) | :: | ab(ldab,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldab | |||
| real(kind=sp), | intent(in) | :: | s(*) | |||
| real(kind=sp), | intent(in) | :: | scond | |||
| real(kind=sp), | intent(in) | :: | amax | |||
| character, | intent(out) | :: | equed |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | kd | |||
| complex(kind=dp), | intent(inout) | :: | ab(ldab,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldab | |||
| real(kind=dp), | intent(in) | :: | s(*) | |||
| real(kind=dp), | intent(in) | :: | scond | |||
| real(kind=dp), | intent(in) | :: | amax | |||
| character, | intent(out) | :: | equed |
CLAQSB equilibrates a symmetric band matrix A using the scaling factors in the vector S.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | kd | |||
| complex(kind=sp), | intent(inout) | :: | ab(ldab,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldab | |||
| real(kind=sp), | intent(in) | :: | s(*) | |||
| real(kind=sp), | intent(in) | :: | scond | |||
| real(kind=sp), | intent(in) | :: | amax | |||
| character, | intent(out) | :: | equed |
DLAQSB equilibrates a symmetric band matrix A using the scaling factors in the vector S.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | kd | |||
| real(kind=dp), | intent(inout) | :: | ab(ldab,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldab | |||
| real(kind=dp), | intent(in) | :: | s(*) | |||
| real(kind=dp), | intent(in) | :: | scond | |||
| real(kind=dp), | intent(in) | :: | amax | |||
| character, | intent(out) | :: | equed |
SLAQSB equilibrates a symmetric band matrix A using the scaling factors in the vector S.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | kd | |||
| real(kind=sp), | intent(inout) | :: | ab(ldab,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldab | |||
| real(kind=sp), | intent(in) | :: | s(*) | |||
| real(kind=sp), | intent(in) | :: | scond | |||
| real(kind=sp), | intent(in) | :: | amax | |||
| character, | intent(out) | :: | equed |
ZLAQSB equilibrates a symmetric band matrix A using the scaling factors in the vector S.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | kd | |||
| complex(kind=dp), | intent(inout) | :: | ab(ldab,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldab | |||
| real(kind=dp), | intent(in) | :: | s(*) | |||
| real(kind=dp), | intent(in) | :: | scond | |||
| real(kind=dp), | intent(in) | :: | amax | |||
| character, | intent(out) | :: | equed |
LAQSP equilibrates a symmetric matrix A using the scaling factors in the vector S.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=sp), | intent(inout) | :: | ap(*) | |||
| real(kind=sp), | intent(in) | :: | s(*) | |||
| real(kind=sp), | intent(in) | :: | scond | |||
| real(kind=sp), | intent(in) | :: | amax | |||
| character, | intent(out) | :: | equed |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=dp), | intent(inout) | :: | ap(*) | |||
| real(kind=dp), | intent(in) | :: | s(*) | |||
| real(kind=dp), | intent(in) | :: | scond | |||
| real(kind=dp), | intent(in) | :: | amax | |||
| character, | intent(out) | :: | equed |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=sp), | intent(inout) | :: | ap(*) | |||
| real(kind=sp), | intent(in) | :: | s(*) | |||
| real(kind=sp), | intent(in) | :: | scond | |||
| real(kind=sp), | intent(in) | :: | amax | |||
| character, | intent(out) | :: | equed |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=dp), | intent(inout) | :: | ap(*) | |||
| real(kind=dp), | intent(in) | :: | s(*) | |||
| real(kind=dp), | intent(in) | :: | scond | |||
| real(kind=dp), | intent(in) | :: | amax | |||
| character, | intent(out) | :: | equed |
CLAQSP equilibrates a symmetric matrix A using the scaling factors in the vector S.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=sp), | intent(inout) | :: | ap(*) | |||
| real(kind=sp), | intent(in) | :: | s(*) | |||
| real(kind=sp), | intent(in) | :: | scond | |||
| real(kind=sp), | intent(in) | :: | amax | |||
| character, | intent(out) | :: | equed |
DLAQSP equilibrates a symmetric matrix A using the scaling factors in the vector S.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=dp), | intent(inout) | :: | ap(*) | |||
| real(kind=dp), | intent(in) | :: | s(*) | |||
| real(kind=dp), | intent(in) | :: | scond | |||
| real(kind=dp), | intent(in) | :: | amax | |||
| character, | intent(out) | :: | equed |
SLAQSP equilibrates a symmetric matrix A using the scaling factors in the vector S.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=sp), | intent(inout) | :: | ap(*) | |||
| real(kind=sp), | intent(in) | :: | s(*) | |||
| real(kind=sp), | intent(in) | :: | scond | |||
| real(kind=sp), | intent(in) | :: | amax | |||
| character, | intent(out) | :: | equed |
ZLAQSP equilibrates a symmetric matrix A using the scaling factors in the vector S.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=dp), | intent(inout) | :: | ap(*) | |||
| real(kind=dp), | intent(in) | :: | s(*) | |||
| real(kind=dp), | intent(in) | :: | scond | |||
| real(kind=dp), | intent(in) | :: | amax | |||
| character, | intent(out) | :: | equed |
LAQSY equilibrates a symmetric matrix A using the scaling factors in the vector S.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=sp), | intent(in) | :: | s(*) | |||
| real(kind=sp), | intent(in) | :: | scond | |||
| real(kind=sp), | intent(in) | :: | amax | |||
| character, | intent(out) | :: | equed |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=dp), | intent(in) | :: | s(*) | |||
| real(kind=dp), | intent(in) | :: | scond | |||
| real(kind=dp), | intent(in) | :: | amax | |||
| character, | intent(out) | :: | equed |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=sp), | intent(in) | :: | s(*) | |||
| real(kind=sp), | intent(in) | :: | scond | |||
| real(kind=sp), | intent(in) | :: | amax | |||
| character, | intent(out) | :: | equed |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=dp), | intent(in) | :: | s(*) | |||
| real(kind=dp), | intent(in) | :: | scond | |||
| real(kind=dp), | intent(in) | :: | amax | |||
| character, | intent(out) | :: | equed |
CLAQSY equilibrates a symmetric matrix A using the scaling factors in the vector S.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=sp), | intent(in) | :: | s(*) | |||
| real(kind=sp), | intent(in) | :: | scond | |||
| real(kind=sp), | intent(in) | :: | amax | |||
| character, | intent(out) | :: | equed |
DLAQSY equilibrates a symmetric matrix A using the scaling factors in the vector S.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=dp), | intent(in) | :: | s(*) | |||
| real(kind=dp), | intent(in) | :: | scond | |||
| real(kind=dp), | intent(in) | :: | amax | |||
| character, | intent(out) | :: | equed |
SLAQSY equilibrates a symmetric matrix A using the scaling factors in the vector S.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=sp), | intent(in) | :: | s(*) | |||
| real(kind=sp), | intent(in) | :: | scond | |||
| real(kind=sp), | intent(in) | :: | amax | |||
| character, | intent(out) | :: | equed |
ZLAQSY equilibrates a symmetric matrix A using the scaling factors in the vector S.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=dp), | intent(in) | :: | s(*) | |||
| real(kind=dp), | intent(in) | :: | scond | |||
| real(kind=dp), | intent(in) | :: | amax | |||
| character, | intent(out) | :: | equed |
LAQTR solves the real quasi-triangular system op(T)p = scalec, if LREAL = .TRUE. or the complex quasi-triangular systems op(T + iB)(p+iq) = scale(c+id), if LREAL = .FALSE. in real arithmetic, where T is upper quasi-triangular. If LREAL = .FALSE., then the first diagonal block of T must be 1 by 1, B is the specially structured matrix B = [ b(1) b(2) ... b(n) ] [ w ] [ w ] [ . ] [ w ] op(A) = A or AT, AT denotes the transpose of matrix A. On input, X = [ c ]. On output, X = [ p ]. [ d ] [ q ] This subroutine is designed for the condition number estimation in routine DTRSNA.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| logical(kind=lk), | intent(in) | :: | ltran | |||
| logical(kind=lk), | intent(in) | :: | lreal | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=dp), | intent(in) | :: | t(ldt,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldt | |||
| real(kind=dp), | intent(in) | :: | b(*) | |||
| real(kind=dp), | intent(in) | :: | w | |||
| real(kind=dp), | intent(out) | :: | scale | |||
| real(kind=dp), | intent(inout) | :: | x(*) | |||
| real(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| logical(kind=lk), | intent(in) | :: | ltran | |||
| logical(kind=lk), | intent(in) | :: | lreal | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=sp), | intent(in) | :: | t(ldt,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldt | |||
| real(kind=sp), | intent(in) | :: | b(*) | |||
| real(kind=sp), | intent(in) | :: | w | |||
| real(kind=sp), | intent(out) | :: | scale | |||
| real(kind=sp), | intent(inout) | :: | x(*) | |||
| real(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
DLAQTR solves the real quasi-triangular system op(T)p = scalec, if LREAL = .TRUE. or the complex quasi-triangular systems op(T + iB)(p+iq) = scale(c+id), if LREAL = .FALSE. in real arithmetic, where T is upper quasi-triangular. If LREAL = .FALSE., then the first diagonal block of T must be 1 by 1, B is the specially structured matrix B = [ b(1) b(2) ... b(n) ] [ w ] [ w ] [ . ] [ w ] op(A) = A or AT, AT denotes the transpose of matrix A. On input, X = [ c ]. On output, X = [ p ]. [ d ] [ q ] This subroutine is designed for the condition number estimation in routine DTRSNA.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| logical(kind=lk), | intent(in) | :: | ltran | |||
| logical(kind=lk), | intent(in) | :: | lreal | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=dp), | intent(in) | :: | t(ldt,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldt | |||
| real(kind=dp), | intent(in) | :: | b(*) | |||
| real(kind=dp), | intent(in) | :: | w | |||
| real(kind=dp), | intent(out) | :: | scale | |||
| real(kind=dp), | intent(inout) | :: | x(*) | |||
| real(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
SLAQTR solves the real quasi-triangular system op(T)p = scalec, if LREAL = .TRUE. or the complex quasi-triangular systems op(T + iB)(p+iq) = scale(c+id), if LREAL = .FALSE. in real arithmetic, where T is upper quasi-triangular. If LREAL = .FALSE., then the first diagonal block of T must be 1 by 1, B is the specially structured matrix B = [ b(1) b(2) ... b(n) ] [ w ] [ w ] [ . ] [ w ] op(A) = A or AT, AT denotes the transpose of matrix A. On input, X = [ c ]. On output, X = [ p ]. [ d ] [ q ] This subroutine is designed for the condition number estimation in routine STRSNA.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| logical(kind=lk), | intent(in) | :: | ltran | |||
| logical(kind=lk), | intent(in) | :: | lreal | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=sp), | intent(in) | :: | t(ldt,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldt | |||
| real(kind=sp), | intent(in) | :: | b(*) | |||
| real(kind=sp), | intent(in) | :: | w | |||
| real(kind=sp), | intent(out) | :: | scale | |||
| real(kind=sp), | intent(inout) | :: | x(*) | |||
| real(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
LAQZ0 computes the eigenvalues of a matrix pair (H,T), where H is an upper Hessenberg matrix and T is upper triangular, using the double-shift QZ method. Matrix pairs of this type are produced by the reduction to generalized upper Hessenberg form of a matrix pair (A,B): A = Q1HZ1H, B = Q1TZ1H, as computed by CGGHRD. If JOB='S', then the Hessenberg-triangular pair (H,T) is also reduced to generalized Schur form, H = QSZH, T = QPZH, where Q and Z are unitary matrices, P and S are an upper triangular matrices. Optionally, the unitary matrix Q from the generalized Schur factorization may be postmultiplied into an input matrix Q1, and the unitary matrix Z may be postmultiplied into an input matrix Z1. If Q1 and Z1 are the unitary matrices from CGGHRD that reduced the matrix pair (A,B) to generalized upper Hessenberg form, then the output matrices Q1Q and Z1Z are the unitary factors from the generalized Schur factorization of (A,B): A = (Q1Q)S(Z1Z)H, B = (Q1Q)P(Z1Z)H. To avoid overflow, eigenvalues of the matrix pair (H,T) (equivalently, of (A,B)) are computed as a pair of values (alpha,beta), where alpha is complex and beta real. If beta is nonzero, lambda = alpha / beta is an eigenvalue of the generalized nonsymmetric eigenvalue problem (GNEP) Ax = lambdaBx and if alpha is nonzero, mu = beta / alpha is an eigenvalue of the alternate form of the GNEP muAy = By. Eigenvalues can be read directly from the generalized Schur form: alpha = S(i,i), beta = P(i,i). Ref: C.B. Moler Eigenvalue Problems", SIAM J. Numer. Anal., 10(1973), pp. 241--256. Ref: B. Kagstrom, D. Kressner, "Multishift Variants of the QZ Algorithm with Aggressive Early Deflation", SIAM J. Numer. Anal., 29(2006), pp. 199--227. Ref: T. Steel, D. Camps, K. Meerbergen, R. Vandebril "A multishift, multipole rational QZ method with agressive early deflation"
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | wants | |||
| character, | intent(in) | :: | wantq | |||
| character, | intent(in) | :: | wantz | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | ilo | |||
| integer(kind=ilp), | intent(in) | :: | ihi | |||
| complex(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=sp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| complex(kind=sp), | intent(inout) | :: | alpha(*) | |||
| complex(kind=sp), | intent(inout) | :: | beta(*) | |||
| complex(kind=sp), | intent(inout) | :: | q(ldq,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldq | |||
| complex(kind=sp), | intent(inout) | :: | z(ldz,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldz | |||
| complex(kind=sp), | intent(inout) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| real(kind=sp), | intent(out) | :: | rwork(*) | |||
| integer(kind=ilp), | intent(in) | :: | rec | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | wants | |||
| character, | intent(in) | :: | wantq | |||
| character, | intent(in) | :: | wantz | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | ilo | |||
| integer(kind=ilp), | intent(in) | :: | ihi | |||
| real(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=dp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| real(kind=dp), | intent(inout) | :: | alphar(*) | |||
| real(kind=dp), | intent(inout) | :: | alphai(*) | |||
| real(kind=dp), | intent(inout) | :: | beta(*) | |||
| real(kind=dp), | intent(inout) | :: | q(ldq,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldq | |||
| real(kind=dp), | intent(inout) | :: | z(ldz,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldz | |||
| real(kind=dp), | intent(inout) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(in) | :: | rec | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | wants | |||
| character, | intent(in) | :: | wantq | |||
| character, | intent(in) | :: | wantz | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | ilo | |||
| integer(kind=ilp), | intent(in) | :: | ihi | |||
| real(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=sp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| real(kind=sp), | intent(inout) | :: | alphar(*) | |||
| real(kind=sp), | intent(inout) | :: | alphai(*) | |||
| real(kind=sp), | intent(inout) | :: | beta(*) | |||
| real(kind=sp), | intent(inout) | :: | q(ldq,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldq | |||
| real(kind=sp), | intent(inout) | :: | z(ldz,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldz | |||
| real(kind=sp), | intent(inout) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(in) | :: | rec | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | wants | |||
| character, | intent(in) | :: | wantq | |||
| character, | intent(in) | :: | wantz | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | ilo | |||
| integer(kind=ilp), | intent(in) | :: | ihi | |||
| complex(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=dp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| complex(kind=dp), | intent(inout) | :: | alpha(*) | |||
| complex(kind=dp), | intent(inout) | :: | beta(*) | |||
| complex(kind=dp), | intent(inout) | :: | q(ldq,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldq | |||
| complex(kind=dp), | intent(inout) | :: | z(ldz,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldz | |||
| complex(kind=dp), | intent(inout) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| real(kind=dp), | intent(out) | :: | rwork(*) | |||
| integer(kind=ilp), | intent(in) | :: | rec | |||
| integer(kind=ilp), | intent(out) | :: | info |
CLAQZ0 computes the eigenvalues of a matrix pair (H,T), where H is an upper Hessenberg matrix and T is upper triangular, using the double-shift QZ method. Matrix pairs of this type are produced by the reduction to generalized upper Hessenberg form of a matrix pair (A,B): A = Q1HZ1H, B = Q1TZ1H, as computed by CGGHRD. If JOB='S', then the Hessenberg-triangular pair (H,T) is also reduced to generalized Schur form, H = QSZH, T = QPZH, where Q and Z are unitary matrices, P and S are an upper triangular matrices. Optionally, the unitary matrix Q from the generalized Schur factorization may be postmultiplied into an input matrix Q1, and the unitary matrix Z may be postmultiplied into an input matrix Z1. If Q1 and Z1 are the unitary matrices from CGGHRD that reduced the matrix pair (A,B) to generalized upper Hessenberg form, then the output matrices Q1Q and Z1Z are the unitary factors from the generalized Schur factorization of (A,B): A = (Q1Q)S(Z1Z)H, B = (Q1Q)P(Z1Z)H. To avoid overflow, eigenvalues of the matrix pair (H,T) (equivalently, of (A,B)) are computed as a pair of values (alpha,beta), where alpha is complex and beta real. If beta is nonzero, lambda = alpha / beta is an eigenvalue of the generalized nonsymmetric eigenvalue problem (GNEP) Ax = lambdaBx and if alpha is nonzero, mu = beta / alpha is an eigenvalue of the alternate form of the GNEP muAy = By. Eigenvalues can be read directly from the generalized Schur form: alpha = S(i,i), beta = P(i,i). Ref: C.B. Moler Eigenvalue Problems", SIAM J. Numer. Anal., 10(1973), pp. 241--256. Ref: B. Kagstrom, D. Kressner, "Multishift Variants of the QZ Algorithm with Aggressive Early Deflation", SIAM J. Numer. Anal., 29(2006), pp. 199--227. Ref: T. Steel, D. Camps, K. Meerbergen, R. Vandebril "A multishift, multipole rational QZ method with agressive early deflation"
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | wants | |||
| character, | intent(in) | :: | wantq | |||
| character, | intent(in) | :: | wantz | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | ilo | |||
| integer(kind=ilp), | intent(in) | :: | ihi | |||
| complex(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=sp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| complex(kind=sp), | intent(inout) | :: | alpha(*) | |||
| complex(kind=sp), | intent(inout) | :: | beta(*) | |||
| complex(kind=sp), | intent(inout) | :: | q(ldq,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldq | |||
| complex(kind=sp), | intent(inout) | :: | z(ldz,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldz | |||
| complex(kind=sp), | intent(inout) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| real(kind=sp), | intent(out) | :: | rwork(*) | |||
| integer(kind=ilp), | intent(in) | :: | rec | |||
| integer(kind=ilp), | intent(out) | :: | info |
DLAQZ0 computes the eigenvalues of a real matrix pair (H,T), where H is an upper Hessenberg matrix and T is upper triangular, using the double-shift QZ method. Matrix pairs of this type are produced by the reduction to generalized upper Hessenberg form of a real matrix pair (A,B): A = Q1HZ1T, B = Q1TZ1T, as computed by DGGHRD. If JOB='S', then the Hessenberg-triangular pair (H,T) is also reduced to generalized Schur form, H = QSZT, T = QPZT, where Q and Z are orthogonal matrices, P is an upper triangular matrix, and S is a quasi-triangular matrix with 1-by-1 and 2-by-2 diagonal blocks. The 1-by-1 blocks correspond to real eigenvalues of the matrix pair (H,T) and the 2-by-2 blocks correspond to complex conjugate pairs of eigenvalues. Additionally, the 2-by-2 upper triangular diagonal blocks of P corresponding to 2-by-2 blocks of S are reduced to positive diagonal form, i.e., if S(j+1,j) is non-zero, then P(j+1,j) = P(j,j+1) = 0, P(j,j) > 0, and P(j+1,j+1) > 0. Optionally, the orthogonal matrix Q from the generalized Schur factorization may be postmultiplied into an input matrix Q1, and the orthogonal matrix Z may be postmultiplied into an input matrix Z1. If Q1 and Z1 are the orthogonal matrices from DGGHRD that reduced the matrix pair (A,B) to generalized upper Hessenberg form, then the output matrices Q1Q and Z1Z are the orthogonal factors from the generalized Schur factorization of (A,B): A = (Q1Q)S(Z1Z)T, B = (Q1Q)P(Z1Z)T. To avoid overflow, eigenvalues of the matrix pair (H,T) (equivalently, of (A,B)) are computed as a pair of values (alpha,beta), where alpha is complex and beta real. If beta is nonzero, lambda = alpha / beta is an eigenvalue of the generalized nonsymmetric eigenvalue problem (GNEP) Ax = lambdaBx and if alpha is nonzero, mu = beta / alpha is an eigenvalue of the alternate form of the GNEP muAy = By. Real eigenvalues can be read directly from the generalized Schur form: alpha = S(i,i), beta = P(i,i). Ref: C.B. Moler Eigenvalue Problems", SIAM J. Numer. Anal., 10(1973), pp. 241--256. Ref: B. Kagstrom, D. Kressner, "Multishift Variants of the QZ Algorithm with Aggressive Early Deflation", SIAM J. Numer. Anal., 29(2006), pp. 199--227. Ref: T. Steel, D. Camps, K. Meerbergen, R. Vandebril "A multishift, multipole rational QZ method with agressive early deflation"
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | wants | |||
| character, | intent(in) | :: | wantq | |||
| character, | intent(in) | :: | wantz | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | ilo | |||
| integer(kind=ilp), | intent(in) | :: | ihi | |||
| real(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=dp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| real(kind=dp), | intent(inout) | :: | alphar(*) | |||
| real(kind=dp), | intent(inout) | :: | alphai(*) | |||
| real(kind=dp), | intent(inout) | :: | beta(*) | |||
| real(kind=dp), | intent(inout) | :: | q(ldq,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldq | |||
| real(kind=dp), | intent(inout) | :: | z(ldz,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldz | |||
| real(kind=dp), | intent(inout) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(in) | :: | rec | |||
| integer(kind=ilp), | intent(out) | :: | info |
SLAQZ0 computes the eigenvalues of a real matrix pair (H,T), where H is an upper Hessenberg matrix and T is upper triangular, using the double-shift QZ method. Matrix pairs of this type are produced by the reduction to generalized upper Hessenberg form of a real matrix pair (A,B): A = Q1HZ1T, B = Q1TZ1T, as computed by SGGHRD. If JOB='S', then the Hessenberg-triangular pair (H,T) is also reduced to generalized Schur form, H = QSZT, T = QPZT, where Q and Z are orthogonal matrices, P is an upper triangular matrix, and S is a quasi-triangular matrix with 1-by-1 and 2-by-2 diagonal blocks. The 1-by-1 blocks correspond to real eigenvalues of the matrix pair (H,T) and the 2-by-2 blocks correspond to complex conjugate pairs of eigenvalues. Additionally, the 2-by-2 upper triangular diagonal blocks of P corresponding to 2-by-2 blocks of S are reduced to positive diagonal form, i.e., if S(j+1,j) is non-zero, then P(j+1,j) = P(j,j+1) = 0, P(j,j) > 0, and P(j+1,j+1) > 0. Optionally, the orthogonal matrix Q from the generalized Schur factorization may be postmultiplied into an input matrix Q1, and the orthogonal matrix Z may be postmultiplied into an input matrix Z1. If Q1 and Z1 are the orthogonal matrices from SGGHRD that reduced the matrix pair (A,B) to generalized upper Hessenberg form, then the output matrices Q1Q and Z1Z are the orthogonal factors from the generalized Schur factorization of (A,B): A = (Q1Q)S(Z1Z)T, B = (Q1Q)P(Z1Z)T. To avoid overflow, eigenvalues of the matrix pair (H,T) (equivalently, of (A,B)) are computed as a pair of values (alpha,beta), where alpha is complex and beta real. If beta is nonzero, lambda = alpha / beta is an eigenvalue of the generalized nonsymmetric eigenvalue problem (GNEP) Ax = lambdaBx and if alpha is nonzero, mu = beta / alpha is an eigenvalue of the alternate form of the GNEP muAy = By. Real eigenvalues can be read directly from the generalized Schur form: alpha = S(i,i), beta = P(i,i). Ref: C.B. Moler Eigenvalue Problems", SIAM J. Numer. Anal., 10(1973), pp. 241--256. Ref: B. Kagstrom, D. Kressner, "Multishift Variants of the QZ Algorithm with Aggressive Early Deflation", SIAM J. Numer. Anal., 29(2006), pp. 199--227. Ref: T. Steel, D. Camps, K. Meerbergen, R. Vandebril "A multishift, multipole rational QZ method with agressive early deflation"
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | wants | |||
| character, | intent(in) | :: | wantq | |||
| character, | intent(in) | :: | wantz | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | ilo | |||
| integer(kind=ilp), | intent(in) | :: | ihi | |||
| real(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=sp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| real(kind=sp), | intent(inout) | :: | alphar(*) | |||
| real(kind=sp), | intent(inout) | :: | alphai(*) | |||
| real(kind=sp), | intent(inout) | :: | beta(*) | |||
| real(kind=sp), | intent(inout) | :: | q(ldq,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldq | |||
| real(kind=sp), | intent(inout) | :: | z(ldz,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldz | |||
| real(kind=sp), | intent(inout) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(in) | :: | rec | |||
| integer(kind=ilp), | intent(out) | :: | info |
ZLAQZ0 computes the eigenvalues of a real matrix pair (H,T), where H is an upper Hessenberg matrix and T is upper triangular, using the double-shift QZ method. Matrix pairs of this type are produced by the reduction to generalized upper Hessenberg form of a real matrix pair (A,B): A = Q1HZ1H, B = Q1TZ1H, as computed by ZGGHRD. If JOB='S', then the Hessenberg-triangular pair (H,T) is also reduced to generalized Schur form, H = QSZH, T = QPZH, where Q and Z are unitary matrices, P and S are an upper triangular matrices. Optionally, the unitary matrix Q from the generalized Schur factorization may be postmultiplied into an input matrix Q1, and the unitary matrix Z may be postmultiplied into an input matrix Z1. If Q1 and Z1 are the unitary matrices from ZGGHRD that reduced the matrix pair (A,B) to generalized upper Hessenberg form, then the output matrices Q1Q and Z1Z are the unitary factors from the generalized Schur factorization of (A,B): A = (Q1Q)S(Z1Z)H, B = (Q1Q)P(Z1Z)H. To avoid overflow, eigenvalues of the matrix pair (H,T) (equivalently, of (A,B)) are computed as a pair of values (alpha,beta), where alpha is complex and beta real. If beta is nonzero, lambda = alpha / beta is an eigenvalue of the generalized nonsymmetric eigenvalue problem (GNEP) Ax = lambdaBx and if alpha is nonzero, mu = beta / alpha is an eigenvalue of the alternate form of the GNEP muAy = By. Eigenvalues can be read directly from the generalized Schur form: alpha = S(i,i), beta = P(i,i). Ref: C.B. Moler Eigenvalue Problems", SIAM J. Numer. Anal., 10(1973), pp. 241--256. Ref: B. Kagstrom, D. Kressner, "Multishift Variants of the QZ Algorithm with Aggressive Early Deflation", SIAM J. Numer. Anal., 29(2006), pp. 199--227. Ref: T. Steel, D. Camps, K. Meerbergen, R. Vandebril "A multishift, multipole rational QZ method with agressive early deflation"
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | wants | |||
| character, | intent(in) | :: | wantq | |||
| character, | intent(in) | :: | wantz | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | ilo | |||
| integer(kind=ilp), | intent(in) | :: | ihi | |||
| complex(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=dp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| complex(kind=dp), | intent(inout) | :: | alpha(*) | |||
| complex(kind=dp), | intent(inout) | :: | beta(*) | |||
| complex(kind=dp), | intent(inout) | :: | q(ldq,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldq | |||
| complex(kind=dp), | intent(inout) | :: | z(ldz,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldz | |||
| complex(kind=dp), | intent(inout) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| real(kind=dp), | intent(out) | :: | rwork(*) | |||
| integer(kind=ilp), | intent(in) | :: | rec | |||
| integer(kind=ilp), | intent(out) | :: | info |
LAQZ1 chases a 1x1 shift bulge in a matrix pencil down a single position
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| logical(kind=lk), | intent(in) | :: | ilq | |||
| logical(kind=lk), | intent(in) | :: | ilz | |||
| integer(kind=ilp), | intent(in) | :: | k | |||
| integer(kind=ilp), | intent(in) | :: | istartm | |||
| integer(kind=ilp), | intent(in) | :: | istopm | |||
| integer(kind=ilp), | intent(in) | :: | ihi | |||
| complex(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=sp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| integer(kind=ilp), | intent(in) | :: | nq | |||
| integer(kind=ilp), | intent(in) | :: | qstart | |||
| complex(kind=sp), | intent(inout) | :: | q(ldq,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldq | |||
| integer(kind=ilp), | intent(in) | :: | nz | |||
| integer(kind=ilp), | intent(in) | :: | zstart | |||
| complex(kind=sp), | intent(inout) | :: | z(ldz,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldz |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| real(kind=dp), | intent(in) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=dp), | intent(in) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| real(kind=dp), | intent(in) | :: | sr1 | |||
| real(kind=dp), | intent(in) | :: | sr2 | |||
| real(kind=dp), | intent(in) | :: | si | |||
| real(kind=dp), | intent(in) | :: | beta1 | |||
| real(kind=dp), | intent(in) | :: | beta2 | |||
| real(kind=dp), | intent(out) | :: | v(*) |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| real(kind=sp), | intent(in) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=sp), | intent(in) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| real(kind=sp), | intent(in) | :: | sr1 | |||
| real(kind=sp), | intent(in) | :: | sr2 | |||
| real(kind=sp), | intent(in) | :: | si | |||
| real(kind=sp), | intent(in) | :: | beta1 | |||
| real(kind=sp), | intent(in) | :: | beta2 | |||
| real(kind=sp), | intent(out) | :: | v(*) |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| logical(kind=lk), | intent(in) | :: | ilq | |||
| logical(kind=lk), | intent(in) | :: | ilz | |||
| integer(kind=ilp), | intent(in) | :: | k | |||
| integer(kind=ilp), | intent(in) | :: | istartm | |||
| integer(kind=ilp), | intent(in) | :: | istopm | |||
| integer(kind=ilp), | intent(in) | :: | ihi | |||
| complex(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=dp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| integer(kind=ilp), | intent(in) | :: | nq | |||
| integer(kind=ilp), | intent(in) | :: | qstart | |||
| complex(kind=dp), | intent(inout) | :: | q(ldq,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldq | |||
| integer(kind=ilp), | intent(in) | :: | nz | |||
| integer(kind=ilp), | intent(in) | :: | zstart | |||
| complex(kind=dp), | intent(inout) | :: | z(ldz,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldz |
CLAQZ1 chases a 1x1 shift bulge in a matrix pencil down a single position
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| logical(kind=lk), | intent(in) | :: | ilq | |||
| logical(kind=lk), | intent(in) | :: | ilz | |||
| integer(kind=ilp), | intent(in) | :: | k | |||
| integer(kind=ilp), | intent(in) | :: | istartm | |||
| integer(kind=ilp), | intent(in) | :: | istopm | |||
| integer(kind=ilp), | intent(in) | :: | ihi | |||
| complex(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=sp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| integer(kind=ilp), | intent(in) | :: | nq | |||
| integer(kind=ilp), | intent(in) | :: | qstart | |||
| complex(kind=sp), | intent(inout) | :: | q(ldq,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldq | |||
| integer(kind=ilp), | intent(in) | :: | nz | |||
| integer(kind=ilp), | intent(in) | :: | zstart | |||
| complex(kind=sp), | intent(inout) | :: | z(ldz,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldz |
Given a 3-by-3 matrix pencil (A,B), DLAQZ1: sets v to a scalar multiple of the first column of the product () K = (A - (beta2sr2 - isi)B)B^(-1)(beta1A - (sr2 + isi2)B)B^(-1). It is assumed that either 1) sr1 = sr2 or 2) si = 0. This is useful for starting double implicit shift bulges in the QZ algorithm.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| real(kind=dp), | intent(in) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=dp), | intent(in) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| real(kind=dp), | intent(in) | :: | sr1 | |||
| real(kind=dp), | intent(in) | :: | sr2 | |||
| real(kind=dp), | intent(in) | :: | si | |||
| real(kind=dp), | intent(in) | :: | beta1 | |||
| real(kind=dp), | intent(in) | :: | beta2 | |||
| real(kind=dp), | intent(out) | :: | v(*) |
Given a 3-by-3 matrix pencil (A,B), SLAQZ1: sets v to a scalar multiple of the first column of the product () K = (A - (beta2sr2 - isi)B)B^(-1)(beta1A - (sr2 + isi2)B)B^(-1). It is assumed that either 1) sr1 = sr2 or 2) si = 0. This is useful for starting double implicit shift bulges in the QZ algorithm.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| real(kind=sp), | intent(in) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=sp), | intent(in) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| real(kind=sp), | intent(in) | :: | sr1 | |||
| real(kind=sp), | intent(in) | :: | sr2 | |||
| real(kind=sp), | intent(in) | :: | si | |||
| real(kind=sp), | intent(in) | :: | beta1 | |||
| real(kind=sp), | intent(in) | :: | beta2 | |||
| real(kind=sp), | intent(out) | :: | v(*) |
ZLAQZ1 chases a 1x1 shift bulge in a matrix pencil down a single position
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| logical(kind=lk), | intent(in) | :: | ilq | |||
| logical(kind=lk), | intent(in) | :: | ilz | |||
| integer(kind=ilp), | intent(in) | :: | k | |||
| integer(kind=ilp), | intent(in) | :: | istartm | |||
| integer(kind=ilp), | intent(in) | :: | istopm | |||
| integer(kind=ilp), | intent(in) | :: | ihi | |||
| complex(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=dp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| integer(kind=ilp), | intent(in) | :: | nq | |||
| integer(kind=ilp), | intent(in) | :: | qstart | |||
| complex(kind=dp), | intent(inout) | :: | q(ldq,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldq | |||
| integer(kind=ilp), | intent(in) | :: | nz | |||
| integer(kind=ilp), | intent(in) | :: | zstart | |||
| complex(kind=dp), | intent(inout) | :: | z(ldz,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldz |
LAQZ4 Executes a single multishift QZ sweep
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| logical(kind=lk), | intent(in) | :: | ilschur | |||
| logical(kind=lk), | intent(in) | :: | ilq | |||
| logical(kind=lk), | intent(in) | :: | ilz | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | ilo | |||
| integer(kind=ilp), | intent(in) | :: | ihi | |||
| integer(kind=ilp), | intent(in) | :: | nshifts | |||
| integer(kind=ilp), | intent(in) | :: | nblock_desired | |||
| real(kind=dp), | intent(inout) | :: | sr(*) | |||
| real(kind=dp), | intent(inout) | :: | si(*) | |||
| real(kind=dp), | intent(inout) | :: | ss(*) | |||
| real(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=dp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| real(kind=dp), | intent(inout) | :: | q(ldq,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldq | |||
| real(kind=dp), | intent(inout) | :: | z(ldz,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldz | |||
| real(kind=dp), | intent(inout) | :: | qc(ldqc,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldqc | |||
| real(kind=dp), | intent(inout) | :: | zc(ldzc,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldzc | |||
| real(kind=dp), | intent(inout) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| logical(kind=lk), | intent(in) | :: | ilschur | |||
| logical(kind=lk), | intent(in) | :: | ilq | |||
| logical(kind=lk), | intent(in) | :: | ilz | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | ilo | |||
| integer(kind=ilp), | intent(in) | :: | ihi | |||
| integer(kind=ilp), | intent(in) | :: | nshifts | |||
| integer(kind=ilp), | intent(in) | :: | nblock_desired | |||
| real(kind=sp), | intent(inout) | :: | sr(*) | |||
| real(kind=sp), | intent(inout) | :: | si(*) | |||
| real(kind=sp), | intent(inout) | :: | ss(*) | |||
| real(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=sp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| real(kind=sp), | intent(inout) | :: | q(ldq,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldq | |||
| real(kind=sp), | intent(inout) | :: | z(ldz,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldz | |||
| real(kind=sp), | intent(inout) | :: | qc(ldqc,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldqc | |||
| real(kind=sp), | intent(inout) | :: | zc(ldzc,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldzc | |||
| real(kind=sp), | intent(inout) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
DLAQZ4 Executes a single multishift QZ sweep
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| logical(kind=lk), | intent(in) | :: | ilschur | |||
| logical(kind=lk), | intent(in) | :: | ilq | |||
| logical(kind=lk), | intent(in) | :: | ilz | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | ilo | |||
| integer(kind=ilp), | intent(in) | :: | ihi | |||
| integer(kind=ilp), | intent(in) | :: | nshifts | |||
| integer(kind=ilp), | intent(in) | :: | nblock_desired | |||
| real(kind=dp), | intent(inout) | :: | sr(*) | |||
| real(kind=dp), | intent(inout) | :: | si(*) | |||
| real(kind=dp), | intent(inout) | :: | ss(*) | |||
| real(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=dp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| real(kind=dp), | intent(inout) | :: | q(ldq,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldq | |||
| real(kind=dp), | intent(inout) | :: | z(ldz,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldz | |||
| real(kind=dp), | intent(inout) | :: | qc(ldqc,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldqc | |||
| real(kind=dp), | intent(inout) | :: | zc(ldzc,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldzc | |||
| real(kind=dp), | intent(inout) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
SLAQZ4 Executes a single multishift QZ sweep
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| logical(kind=lk), | intent(in) | :: | ilschur | |||
| logical(kind=lk), | intent(in) | :: | ilq | |||
| logical(kind=lk), | intent(in) | :: | ilz | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | ilo | |||
| integer(kind=ilp), | intent(in) | :: | ihi | |||
| integer(kind=ilp), | intent(in) | :: | nshifts | |||
| integer(kind=ilp), | intent(in) | :: | nblock_desired | |||
| real(kind=sp), | intent(inout) | :: | sr(*) | |||
| real(kind=sp), | intent(inout) | :: | si(*) | |||
| real(kind=sp), | intent(inout) | :: | ss(*) | |||
| real(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=sp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| real(kind=sp), | intent(inout) | :: | q(ldq,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldq | |||
| real(kind=sp), | intent(inout) | :: | z(ldz,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldz | |||
| real(kind=sp), | intent(inout) | :: | qc(ldqc,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldqc | |||
| real(kind=sp), | intent(inout) | :: | zc(ldzc,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldzc | |||
| real(kind=sp), | intent(inout) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
LAR1V computes the (scaled) r-th column of the inverse of the sumbmatrix in rows B1 through BN of the tridiagonal matrix L D LT - sigma I. When sigma is close to an eigenvalue, the computed vector is an accurate eigenvector. Usually, r corresponds to the index where the eigenvector is largest in magnitude. The following steps accomplish this computation : (a) Stationary qd transform, L D LT - sigma I = L(+) D(+) L(+)T, (b) Progressive qd transform, L D LT - sigma I = U(-) D(-) U(-)T, (c) Computation of the diagonal elements of the inverse of L D LT - sigma I by combining the above transforms, and choosing r as the index where the diagonal of the inverse is (one of the) largest in magnitude. (d) Computation of the (scaled) r-th column of the inverse using the twisted factorization obtained by combining the top part of the the stationary and the bottom part of the progressive transform.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | b1 | |||
| integer(kind=ilp), | intent(in) | :: | bn | |||
| real(kind=sp), | intent(in) | :: | lambda | |||
| real(kind=sp), | intent(in) | :: | d(*) | |||
| real(kind=sp), | intent(in) | :: | l(*) | |||
| real(kind=sp), | intent(in) | :: | ld(*) | |||
| real(kind=sp), | intent(in) | :: | lld(*) | |||
| real(kind=sp), | intent(in) | :: | pivmin | |||
| real(kind=sp), | intent(in) | :: | gaptol | |||
| complex(kind=sp), | intent(inout) | :: | z(*) | |||
| logical(kind=lk), | intent(in) | :: | wantnc | |||
| integer(kind=ilp), | intent(out) | :: | negcnt | |||
| real(kind=sp), | intent(out) | :: | ztz | |||
| real(kind=sp), | intent(out) | :: | mingma | |||
| integer(kind=ilp), | intent(inout) | :: | r | |||
| integer(kind=ilp), | intent(out) | :: | isuppz(*) | |||
| real(kind=sp), | intent(out) | :: | nrminv | |||
| real(kind=sp), | intent(out) | :: | resid | |||
| real(kind=sp), | intent(out) | :: | rqcorr | |||
| real(kind=sp), | intent(out) | :: | work(*) |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | b1 | |||
| integer(kind=ilp), | intent(in) | :: | bn | |||
| real(kind=dp), | intent(in) | :: | lambda | |||
| real(kind=dp), | intent(in) | :: | d(*) | |||
| real(kind=dp), | intent(in) | :: | l(*) | |||
| real(kind=dp), | intent(in) | :: | ld(*) | |||
| real(kind=dp), | intent(in) | :: | lld(*) | |||
| real(kind=dp), | intent(in) | :: | pivmin | |||
| real(kind=dp), | intent(in) | :: | gaptol | |||
| real(kind=dp), | intent(inout) | :: | z(*) | |||
| logical(kind=lk), | intent(in) | :: | wantnc | |||
| integer(kind=ilp), | intent(out) | :: | negcnt | |||
| real(kind=dp), | intent(out) | :: | ztz | |||
| real(kind=dp), | intent(out) | :: | mingma | |||
| integer(kind=ilp), | intent(inout) | :: | r | |||
| integer(kind=ilp), | intent(out) | :: | isuppz(*) | |||
| real(kind=dp), | intent(out) | :: | nrminv | |||
| real(kind=dp), | intent(out) | :: | resid | |||
| real(kind=dp), | intent(out) | :: | rqcorr | |||
| real(kind=dp), | intent(out) | :: | work(*) |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | b1 | |||
| integer(kind=ilp), | intent(in) | :: | bn | |||
| real(kind=sp), | intent(in) | :: | lambda | |||
| real(kind=sp), | intent(in) | :: | d(*) | |||
| real(kind=sp), | intent(in) | :: | l(*) | |||
| real(kind=sp), | intent(in) | :: | ld(*) | |||
| real(kind=sp), | intent(in) | :: | lld(*) | |||
| real(kind=sp), | intent(in) | :: | pivmin | |||
| real(kind=sp), | intent(in) | :: | gaptol | |||
| real(kind=sp), | intent(inout) | :: | z(*) | |||
| logical(kind=lk), | intent(in) | :: | wantnc | |||
| integer(kind=ilp), | intent(out) | :: | negcnt | |||
| real(kind=sp), | intent(out) | :: | ztz | |||
| real(kind=sp), | intent(out) | :: | mingma | |||
| integer(kind=ilp), | intent(inout) | :: | r | |||
| integer(kind=ilp), | intent(out) | :: | isuppz(*) | |||
| real(kind=sp), | intent(out) | :: | nrminv | |||
| real(kind=sp), | intent(out) | :: | resid | |||
| real(kind=sp), | intent(out) | :: | rqcorr | |||
| real(kind=sp), | intent(out) | :: | work(*) |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | b1 | |||
| integer(kind=ilp), | intent(in) | :: | bn | |||
| real(kind=dp), | intent(in) | :: | lambda | |||
| real(kind=dp), | intent(in) | :: | d(*) | |||
| real(kind=dp), | intent(in) | :: | l(*) | |||
| real(kind=dp), | intent(in) | :: | ld(*) | |||
| real(kind=dp), | intent(in) | :: | lld(*) | |||
| real(kind=dp), | intent(in) | :: | pivmin | |||
| real(kind=dp), | intent(in) | :: | gaptol | |||
| complex(kind=dp), | intent(inout) | :: | z(*) | |||
| logical(kind=lk), | intent(in) | :: | wantnc | |||
| integer(kind=ilp), | intent(out) | :: | negcnt | |||
| real(kind=dp), | intent(out) | :: | ztz | |||
| real(kind=dp), | intent(out) | :: | mingma | |||
| integer(kind=ilp), | intent(inout) | :: | r | |||
| integer(kind=ilp), | intent(out) | :: | isuppz(*) | |||
| real(kind=dp), | intent(out) | :: | nrminv | |||
| real(kind=dp), | intent(out) | :: | resid | |||
| real(kind=dp), | intent(out) | :: | rqcorr | |||
| real(kind=dp), | intent(out) | :: | work(*) |
CLAR1V computes the (scaled) r-th column of the inverse of the sumbmatrix in rows B1 through BN of the tridiagonal matrix L D LT - sigma I. When sigma is close to an eigenvalue, the computed vector is an accurate eigenvector. Usually, r corresponds to the index where the eigenvector is largest in magnitude. The following steps accomplish this computation : (a) Stationary qd transform, L D LT - sigma I = L(+) D(+) L(+)T, (b) Progressive qd transform, L D LT - sigma I = U(-) D(-) U(-)T, (c) Computation of the diagonal elements of the inverse of L D LT - sigma I by combining the above transforms, and choosing r as the index where the diagonal of the inverse is (one of the) largest in magnitude. (d) Computation of the (scaled) r-th column of the inverse using the twisted factorization obtained by combining the top part of the the stationary and the bottom part of the progressive transform.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | b1 | |||
| integer(kind=ilp), | intent(in) | :: | bn | |||
| real(kind=sp), | intent(in) | :: | lambda | |||
| real(kind=sp), | intent(in) | :: | d(*) | |||
| real(kind=sp), | intent(in) | :: | l(*) | |||
| real(kind=sp), | intent(in) | :: | ld(*) | |||
| real(kind=sp), | intent(in) | :: | lld(*) | |||
| real(kind=sp), | intent(in) | :: | pivmin | |||
| real(kind=sp), | intent(in) | :: | gaptol | |||
| complex(kind=sp), | intent(inout) | :: | z(*) | |||
| logical(kind=lk), | intent(in) | :: | wantnc | |||
| integer(kind=ilp), | intent(out) | :: | negcnt | |||
| real(kind=sp), | intent(out) | :: | ztz | |||
| real(kind=sp), | intent(out) | :: | mingma | |||
| integer(kind=ilp), | intent(inout) | :: | r | |||
| integer(kind=ilp), | intent(out) | :: | isuppz(*) | |||
| real(kind=sp), | intent(out) | :: | nrminv | |||
| real(kind=sp), | intent(out) | :: | resid | |||
| real(kind=sp), | intent(out) | :: | rqcorr | |||
| real(kind=sp), | intent(out) | :: | work(*) |
DLAR1V computes the (scaled) r-th column of the inverse of the sumbmatrix in rows B1 through BN of the tridiagonal matrix L D LT - sigma I. When sigma is close to an eigenvalue, the computed vector is an accurate eigenvector. Usually, r corresponds to the index where the eigenvector is largest in magnitude. The following steps accomplish this computation : (a) Stationary qd transform, L D LT - sigma I = L(+) D(+) L(+)T, (b) Progressive qd transform, L D LT - sigma I = U(-) D(-) U(-)T, (c) Computation of the diagonal elements of the inverse of L D LT - sigma I by combining the above transforms, and choosing r as the index where the diagonal of the inverse is (one of the) largest in magnitude. (d) Computation of the (scaled) r-th column of the inverse using the twisted factorization obtained by combining the top part of the the stationary and the bottom part of the progressive transform.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | b1 | |||
| integer(kind=ilp), | intent(in) | :: | bn | |||
| real(kind=dp), | intent(in) | :: | lambda | |||
| real(kind=dp), | intent(in) | :: | d(*) | |||
| real(kind=dp), | intent(in) | :: | l(*) | |||
| real(kind=dp), | intent(in) | :: | ld(*) | |||
| real(kind=dp), | intent(in) | :: | lld(*) | |||
| real(kind=dp), | intent(in) | :: | pivmin | |||
| real(kind=dp), | intent(in) | :: | gaptol | |||
| real(kind=dp), | intent(inout) | :: | z(*) | |||
| logical(kind=lk), | intent(in) | :: | wantnc | |||
| integer(kind=ilp), | intent(out) | :: | negcnt | |||
| real(kind=dp), | intent(out) | :: | ztz | |||
| real(kind=dp), | intent(out) | :: | mingma | |||
| integer(kind=ilp), | intent(inout) | :: | r | |||
| integer(kind=ilp), | intent(out) | :: | isuppz(*) | |||
| real(kind=dp), | intent(out) | :: | nrminv | |||
| real(kind=dp), | intent(out) | :: | resid | |||
| real(kind=dp), | intent(out) | :: | rqcorr | |||
| real(kind=dp), | intent(out) | :: | work(*) |
SLAR1V computes the (scaled) r-th column of the inverse of the sumbmatrix in rows B1 through BN of the tridiagonal matrix L D LT - sigma I. When sigma is close to an eigenvalue, the computed vector is an accurate eigenvector. Usually, r corresponds to the index where the eigenvector is largest in magnitude. The following steps accomplish this computation : (a) Stationary qd transform, L D LT - sigma I = L(+) D(+) L(+)T, (b) Progressive qd transform, L D LT - sigma I = U(-) D(-) U(-)T, (c) Computation of the diagonal elements of the inverse of L D LT - sigma I by combining the above transforms, and choosing r as the index where the diagonal of the inverse is (one of the) largest in magnitude. (d) Computation of the (scaled) r-th column of the inverse using the twisted factorization obtained by combining the top part of the the stationary and the bottom part of the progressive transform.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | b1 | |||
| integer(kind=ilp), | intent(in) | :: | bn | |||
| real(kind=sp), | intent(in) | :: | lambda | |||
| real(kind=sp), | intent(in) | :: | d(*) | |||
| real(kind=sp), | intent(in) | :: | l(*) | |||
| real(kind=sp), | intent(in) | :: | ld(*) | |||
| real(kind=sp), | intent(in) | :: | lld(*) | |||
| real(kind=sp), | intent(in) | :: | pivmin | |||
| real(kind=sp), | intent(in) | :: | gaptol | |||
| real(kind=sp), | intent(inout) | :: | z(*) | |||
| logical(kind=lk), | intent(in) | :: | wantnc | |||
| integer(kind=ilp), | intent(out) | :: | negcnt | |||
| real(kind=sp), | intent(out) | :: | ztz | |||
| real(kind=sp), | intent(out) | :: | mingma | |||
| integer(kind=ilp), | intent(inout) | :: | r | |||
| integer(kind=ilp), | intent(out) | :: | isuppz(*) | |||
| real(kind=sp), | intent(out) | :: | nrminv | |||
| real(kind=sp), | intent(out) | :: | resid | |||
| real(kind=sp), | intent(out) | :: | rqcorr | |||
| real(kind=sp), | intent(out) | :: | work(*) |
ZLAR1V computes the (scaled) r-th column of the inverse of the sumbmatrix in rows B1 through BN of the tridiagonal matrix L D LT - sigma I. When sigma is close to an eigenvalue, the computed vector is an accurate eigenvector. Usually, r corresponds to the index where the eigenvector is largest in magnitude. The following steps accomplish this computation : (a) Stationary qd transform, L D LT - sigma I = L(+) D(+) L(+)T, (b) Progressive qd transform, L D LT - sigma I = U(-) D(-) U(-)T, (c) Computation of the diagonal elements of the inverse of L D LT - sigma I by combining the above transforms, and choosing r as the index where the diagonal of the inverse is (one of the) largest in magnitude. (d) Computation of the (scaled) r-th column of the inverse using the twisted factorization obtained by combining the top part of the the stationary and the bottom part of the progressive transform.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | b1 | |||
| integer(kind=ilp), | intent(in) | :: | bn | |||
| real(kind=dp), | intent(in) | :: | lambda | |||
| real(kind=dp), | intent(in) | :: | d(*) | |||
| real(kind=dp), | intent(in) | :: | l(*) | |||
| real(kind=dp), | intent(in) | :: | ld(*) | |||
| real(kind=dp), | intent(in) | :: | lld(*) | |||
| real(kind=dp), | intent(in) | :: | pivmin | |||
| real(kind=dp), | intent(in) | :: | gaptol | |||
| complex(kind=dp), | intent(inout) | :: | z(*) | |||
| logical(kind=lk), | intent(in) | :: | wantnc | |||
| integer(kind=ilp), | intent(out) | :: | negcnt | |||
| real(kind=dp), | intent(out) | :: | ztz | |||
| real(kind=dp), | intent(out) | :: | mingma | |||
| integer(kind=ilp), | intent(inout) | :: | r | |||
| integer(kind=ilp), | intent(out) | :: | isuppz(*) | |||
| real(kind=dp), | intent(out) | :: | nrminv | |||
| real(kind=dp), | intent(out) | :: | resid | |||
| real(kind=dp), | intent(out) | :: | rqcorr | |||
| real(kind=dp), | intent(out) | :: | work(*) |
LAR2V applies a vector of complex plane rotations with real cosines from both sides to a sequence of 2-by-2 complex Hermitian matrices, defined by the elements of the vectors x, y and z. For i = 1,2,...,n ( x(i) z(i) ) := ( conjg(z(i)) y(i) ) ( c(i) conjg(s(i)) ) ( x(i) z(i) ) ( c(i) -conjg(s(i)) ) ( -s(i) c(i) ) ( conjg(z(i)) y(i) ) ( s(i) c(i) )
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=sp), | intent(inout) | :: | x(*) | |||
| complex(kind=sp), | intent(inout) | :: | y(*) | |||
| complex(kind=sp), | intent(inout) | :: | z(*) | |||
| integer(kind=ilp), | intent(in) | :: | incx | |||
| real(kind=sp), | intent(in) | :: | c(*) | |||
| complex(kind=sp), | intent(in) | :: | s(*) | |||
| integer(kind=ilp), | intent(in) | :: | incc |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=dp), | intent(inout) | :: | x(*) | |||
| real(kind=dp), | intent(inout) | :: | y(*) | |||
| real(kind=dp), | intent(inout) | :: | z(*) | |||
| integer(kind=ilp), | intent(in) | :: | incx | |||
| real(kind=dp), | intent(in) | :: | c(*) | |||
| real(kind=dp), | intent(in) | :: | s(*) | |||
| integer(kind=ilp), | intent(in) | :: | incc |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=sp), | intent(inout) | :: | x(*) | |||
| real(kind=sp), | intent(inout) | :: | y(*) | |||
| real(kind=sp), | intent(inout) | :: | z(*) | |||
| integer(kind=ilp), | intent(in) | :: | incx | |||
| real(kind=sp), | intent(in) | :: | c(*) | |||
| real(kind=sp), | intent(in) | :: | s(*) | |||
| integer(kind=ilp), | intent(in) | :: | incc |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=dp), | intent(inout) | :: | x(*) | |||
| complex(kind=dp), | intent(inout) | :: | y(*) | |||
| complex(kind=dp), | intent(inout) | :: | z(*) | |||
| integer(kind=ilp), | intent(in) | :: | incx | |||
| real(kind=dp), | intent(in) | :: | c(*) | |||
| complex(kind=dp), | intent(in) | :: | s(*) | |||
| integer(kind=ilp), | intent(in) | :: | incc |
CLAR2V applies a vector of complex plane rotations with real cosines from both sides to a sequence of 2-by-2 complex Hermitian matrices, defined by the elements of the vectors x, y and z. For i = 1,2,...,n ( x(i) z(i) ) := ( conjg(z(i)) y(i) ) ( c(i) conjg(s(i)) ) ( x(i) z(i) ) ( c(i) -conjg(s(i)) ) ( -s(i) c(i) ) ( conjg(z(i)) y(i) ) ( s(i) c(i) )
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=sp), | intent(inout) | :: | x(*) | |||
| complex(kind=sp), | intent(inout) | :: | y(*) | |||
| complex(kind=sp), | intent(inout) | :: | z(*) | |||
| integer(kind=ilp), | intent(in) | :: | incx | |||
| real(kind=sp), | intent(in) | :: | c(*) | |||
| complex(kind=sp), | intent(in) | :: | s(*) | |||
| integer(kind=ilp), | intent(in) | :: | incc |
DLAR2V applies a vector of real plane rotations from both sides to a sequence of 2-by-2 real symmetric matrices, defined by the elements of the vectors x, y and z. For i = 1,2,...,n ( x(i) z(i) ) := ( c(i) s(i) ) ( x(i) z(i) ) ( c(i) -s(i) ) ( z(i) y(i) ) ( -s(i) c(i) ) ( z(i) y(i) ) ( s(i) c(i) )
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=dp), | intent(inout) | :: | x(*) | |||
| real(kind=dp), | intent(inout) | :: | y(*) | |||
| real(kind=dp), | intent(inout) | :: | z(*) | |||
| integer(kind=ilp), | intent(in) | :: | incx | |||
| real(kind=dp), | intent(in) | :: | c(*) | |||
| real(kind=dp), | intent(in) | :: | s(*) | |||
| integer(kind=ilp), | intent(in) | :: | incc |
SLAR2V applies a vector of real plane rotations from both sides to a sequence of 2-by-2 real symmetric matrices, defined by the elements of the vectors x, y and z. For i = 1,2,...,n ( x(i) z(i) ) := ( c(i) s(i) ) ( x(i) z(i) ) ( c(i) -s(i) ) ( z(i) y(i) ) ( -s(i) c(i) ) ( z(i) y(i) ) ( s(i) c(i) )
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=sp), | intent(inout) | :: | x(*) | |||
| real(kind=sp), | intent(inout) | :: | y(*) | |||
| real(kind=sp), | intent(inout) | :: | z(*) | |||
| integer(kind=ilp), | intent(in) | :: | incx | |||
| real(kind=sp), | intent(in) | :: | c(*) | |||
| real(kind=sp), | intent(in) | :: | s(*) | |||
| integer(kind=ilp), | intent(in) | :: | incc |
ZLAR2V applies a vector of complex plane rotations with real cosines from both sides to a sequence of 2-by-2 complex Hermitian matrices, defined by the elements of the vectors x, y and z. For i = 1,2,...,n ( x(i) z(i) ) := ( conjg(z(i)) y(i) ) ( c(i) conjg(s(i)) ) ( x(i) z(i) ) ( c(i) -conjg(s(i)) ) ( -s(i) c(i) ) ( conjg(z(i)) y(i) ) ( s(i) c(i) )
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=dp), | intent(inout) | :: | x(*) | |||
| complex(kind=dp), | intent(inout) | :: | y(*) | |||
| complex(kind=dp), | intent(inout) | :: | z(*) | |||
| integer(kind=ilp), | intent(in) | :: | incx | |||
| real(kind=dp), | intent(in) | :: | c(*) | |||
| complex(kind=dp), | intent(in) | :: | s(*) | |||
| integer(kind=ilp), | intent(in) | :: | incc |
LARCM performs a very simple matrix-matrix multiplication: C := A * B, where A is M by M and real; B is M by N and complex; C is M by N and complex.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=sp), | intent(in) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=sp), | intent(in) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| complex(kind=sp), | intent(out) | :: | c(ldc,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldc | |||
| real(kind=sp), | intent(out) | :: | rwork(*) |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=dp), | intent(in) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=dp), | intent(in) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| complex(kind=dp), | intent(out) | :: | c(ldc,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldc | |||
| real(kind=dp), | intent(out) | :: | rwork(*) |
CLARCM performs a very simple matrix-matrix multiplication: C := A * B, where A is M by M and real; B is M by N and complex; C is M by N and complex.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=sp), | intent(in) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=sp), | intent(in) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| complex(kind=sp), | intent(out) | :: | c(ldc,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldc | |||
| real(kind=sp), | intent(out) | :: | rwork(*) |
ZLARCM performs a very simple matrix-matrix multiplication: C := A * B, where A is M by M and real; B is M by N and complex; C is M by N and complex.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=dp), | intent(in) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=dp), | intent(in) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| complex(kind=dp), | intent(out) | :: | c(ldc,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldc | |||
| real(kind=dp), | intent(out) | :: | rwork(*) |
LARF applies a complex elementary reflector H to a complex M-by-N matrix C, from either the left or the right. H is represented in the form H = I - tau * v * vH where tau is a complex scalar and v is a complex vector. If tau = 0, then H is taken to be the unit matrix. To apply HH (the conjugate transpose of H), supply conjg(tau) instead tau.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | side | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=sp), | intent(in) | :: | v(*) | |||
| integer(kind=ilp), | intent(in) | :: | incv | |||
| complex(kind=sp), | intent(in) | :: | tau | |||
| complex(kind=sp), | intent(inout) | :: | c(ldc,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldc | |||
| complex(kind=sp), | intent(out) | :: | work(*) |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | side | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=dp), | intent(in) | :: | v(*) | |||
| integer(kind=ilp), | intent(in) | :: | incv | |||
| real(kind=dp), | intent(in) | :: | tau | |||
| real(kind=dp), | intent(inout) | :: | c(ldc,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldc | |||
| real(kind=dp), | intent(out) | :: | work(*) |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | side | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=sp), | intent(in) | :: | v(*) | |||
| integer(kind=ilp), | intent(in) | :: | incv | |||
| real(kind=sp), | intent(in) | :: | tau | |||
| real(kind=sp), | intent(inout) | :: | c(ldc,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldc | |||
| real(kind=sp), | intent(out) | :: | work(*) |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | side | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=dp), | intent(in) | :: | v(*) | |||
| integer(kind=ilp), | intent(in) | :: | incv | |||
| complex(kind=dp), | intent(in) | :: | tau | |||
| complex(kind=dp), | intent(inout) | :: | c(ldc,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldc | |||
| complex(kind=dp), | intent(out) | :: | work(*) |
CLARF applies a complex elementary reflector H to a complex M-by-N matrix C, from either the left or the right. H is represented in the form H = I - tau * v * vH where tau is a complex scalar and v is a complex vector. If tau = 0, then H is taken to be the unit matrix. To apply HH (the conjugate transpose of H), supply conjg(tau) instead tau.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | side | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=sp), | intent(in) | :: | v(*) | |||
| integer(kind=ilp), | intent(in) | :: | incv | |||
| complex(kind=sp), | intent(in) | :: | tau | |||
| complex(kind=sp), | intent(inout) | :: | c(ldc,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldc | |||
| complex(kind=sp), | intent(out) | :: | work(*) |
DLARF applies a real elementary reflector H to a real m by n matrix C, from either the left or the right. H is represented in the form H = I - tau * v * v**T where tau is a real scalar and v is a real vector. If tau = 0, then H is taken to be the unit matrix.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | side | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=dp), | intent(in) | :: | v(*) | |||
| integer(kind=ilp), | intent(in) | :: | incv | |||
| real(kind=dp), | intent(in) | :: | tau | |||
| real(kind=dp), | intent(inout) | :: | c(ldc,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldc | |||
| real(kind=dp), | intent(out) | :: | work(*) |
SLARF applies a real elementary reflector H to a real m by n matrix C, from either the left or the right. H is represented in the form H = I - tau * v * v**T where tau is a real scalar and v is a real vector. If tau = 0, then H is taken to be the unit matrix.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | side | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=sp), | intent(in) | :: | v(*) | |||
| integer(kind=ilp), | intent(in) | :: | incv | |||
| real(kind=sp), | intent(in) | :: | tau | |||
| real(kind=sp), | intent(inout) | :: | c(ldc,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldc | |||
| real(kind=sp), | intent(out) | :: | work(*) |
ZLARF applies a complex elementary reflector H to a complex M-by-N matrix C, from either the left or the right. H is represented in the form H = I - tau * v * vH where tau is a complex scalar and v is a complex vector. If tau = 0, then H is taken to be the unit matrix. To apply HH, supply conjg(tau) instead tau.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | side | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=dp), | intent(in) | :: | v(*) | |||
| integer(kind=ilp), | intent(in) | :: | incv | |||
| complex(kind=dp), | intent(in) | :: | tau | |||
| complex(kind=dp), | intent(inout) | :: | c(ldc,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldc | |||
| complex(kind=dp), | intent(out) | :: | work(*) |
LARFB applies a complex block reflector H or its transpose H**H to a complex M-by-N matrix C, from either the left or the right.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | side | |||
| character, | intent(in) | :: | trans | |||
| character, | intent(in) | :: | direct | |||
| character, | intent(in) | :: | storev | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | k | |||
| complex(kind=sp), | intent(in) | :: | v(ldv,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldv | |||
| complex(kind=sp), | intent(in) | :: | t(ldt,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldt | |||
| complex(kind=sp), | intent(inout) | :: | c(ldc,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldc | |||
| complex(kind=sp), | intent(out) | :: | work(ldwork,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldwork |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | side | |||
| character, | intent(in) | :: | trans | |||
| character, | intent(in) | :: | direct | |||
| character, | intent(in) | :: | storev | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | k | |||
| real(kind=dp), | intent(in) | :: | v(ldv,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldv | |||
| real(kind=dp), | intent(in) | :: | t(ldt,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldt | |||
| real(kind=dp), | intent(inout) | :: | c(ldc,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldc | |||
| real(kind=dp), | intent(out) | :: | work(ldwork,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldwork |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | side | |||
| character, | intent(in) | :: | trans | |||
| character, | intent(in) | :: | direct | |||
| character, | intent(in) | :: | storev | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | k | |||
| real(kind=sp), | intent(in) | :: | v(ldv,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldv | |||
| real(kind=sp), | intent(in) | :: | t(ldt,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldt | |||
| real(kind=sp), | intent(inout) | :: | c(ldc,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldc | |||
| real(kind=sp), | intent(out) | :: | work(ldwork,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldwork |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | side | |||
| character, | intent(in) | :: | trans | |||
| character, | intent(in) | :: | direct | |||
| character, | intent(in) | :: | storev | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | k | |||
| complex(kind=dp), | intent(in) | :: | v(ldv,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldv | |||
| complex(kind=dp), | intent(in) | :: | t(ldt,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldt | |||
| complex(kind=dp), | intent(inout) | :: | c(ldc,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldc | |||
| complex(kind=dp), | intent(out) | :: | work(ldwork,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldwork |
CLARFB applies a complex block reflector H or its transpose H**H to a complex M-by-N matrix C, from either the left or the right.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | side | |||
| character, | intent(in) | :: | trans | |||
| character, | intent(in) | :: | direct | |||
| character, | intent(in) | :: | storev | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | k | |||
| complex(kind=sp), | intent(in) | :: | v(ldv,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldv | |||
| complex(kind=sp), | intent(in) | :: | t(ldt,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldt | |||
| complex(kind=sp), | intent(inout) | :: | c(ldc,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldc | |||
| complex(kind=sp), | intent(out) | :: | work(ldwork,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldwork |
DLARFB applies a real block reflector H or its transpose H**T to a real m by n matrix C, from either the left or the right.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | side | |||
| character, | intent(in) | :: | trans | |||
| character, | intent(in) | :: | direct | |||
| character, | intent(in) | :: | storev | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | k | |||
| real(kind=dp), | intent(in) | :: | v(ldv,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldv | |||
| real(kind=dp), | intent(in) | :: | t(ldt,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldt | |||
| real(kind=dp), | intent(inout) | :: | c(ldc,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldc | |||
| real(kind=dp), | intent(out) | :: | work(ldwork,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldwork |
SLARFB applies a real block reflector H or its transpose H**T to a real m by n matrix C, from either the left or the right.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | side | |||
| character, | intent(in) | :: | trans | |||
| character, | intent(in) | :: | direct | |||
| character, | intent(in) | :: | storev | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | k | |||
| real(kind=sp), | intent(in) | :: | v(ldv,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldv | |||
| real(kind=sp), | intent(in) | :: | t(ldt,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldt | |||
| real(kind=sp), | intent(inout) | :: | c(ldc,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldc | |||
| real(kind=sp), | intent(out) | :: | work(ldwork,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldwork |
ZLARFB applies a complex block reflector H or its transpose H**H to a complex M-by-N matrix C, from either the left or the right.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | side | |||
| character, | intent(in) | :: | trans | |||
| character, | intent(in) | :: | direct | |||
| character, | intent(in) | :: | storev | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | k | |||
| complex(kind=dp), | intent(in) | :: | v(ldv,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldv | |||
| complex(kind=dp), | intent(in) | :: | t(ldt,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldt | |||
| complex(kind=dp), | intent(inout) | :: | c(ldc,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldc | |||
| complex(kind=dp), | intent(out) | :: | work(ldwork,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldwork |
LARFB_GETT applies a complex Householder block reflector H from the left to a complex (K+M)-by-N "triangular-pentagonal" matrix composed of two block matrices: an upper trapezoidal K-by-N matrix A stored in the array A, and a rectangular M-by-(N-K) matrix B, stored in the array B. The block reflector H is stored in a compact WY-representation, where the elementary reflectors are in the arrays A, B and T. See Further Details section.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | ident | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | k | |||
| complex(kind=sp), | intent(in) | :: | t(ldt,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldt | |||
| complex(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=sp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| complex(kind=sp), | intent(out) | :: | work(ldwork,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldwork |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | ident | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | k | |||
| real(kind=dp), | intent(in) | :: | t(ldt,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldt | |||
| real(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=dp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| real(kind=dp), | intent(out) | :: | work(ldwork,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldwork |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | ident | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | k | |||
| real(kind=sp), | intent(in) | :: | t(ldt,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldt | |||
| real(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=sp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| real(kind=sp), | intent(out) | :: | work(ldwork,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldwork |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | ident | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | k | |||
| complex(kind=dp), | intent(in) | :: | t(ldt,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldt | |||
| complex(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=dp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| complex(kind=dp), | intent(out) | :: | work(ldwork,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldwork |
CLARFB_GETT applies a complex Householder block reflector H from the left to a complex (K+M)-by-N "triangular-pentagonal" matrix composed of two block matrices: an upper trapezoidal K-by-N matrix A stored in the array A, and a rectangular M-by-(N-K) matrix B, stored in the array B. The block reflector H is stored in a compact WY-representation, where the elementary reflectors are in the arrays A, B and T. See Further Details section.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | ident | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | k | |||
| complex(kind=sp), | intent(in) | :: | t(ldt,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldt | |||
| complex(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=sp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| complex(kind=sp), | intent(out) | :: | work(ldwork,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldwork |
DLARFB_GETT applies a real Householder block reflector H from the left to a real (K+M)-by-N "triangular-pentagonal" matrix composed of two block matrices: an upper trapezoidal K-by-N matrix A stored in the array A, and a rectangular M-by-(N-K) matrix B, stored in the array B. The block reflector H is stored in a compact WY-representation, where the elementary reflectors are in the arrays A, B and T. See Further Details section.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | ident | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | k | |||
| real(kind=dp), | intent(in) | :: | t(ldt,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldt | |||
| real(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=dp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| real(kind=dp), | intent(out) | :: | work(ldwork,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldwork |
SLARFB_GETT applies a real Householder block reflector H from the left to a real (K+M)-by-N "triangular-pentagonal" matrix composed of two block matrices: an upper trapezoidal K-by-N matrix A stored in the array A, and a rectangular M-by-(N-K) matrix B, stored in the array B. The block reflector H is stored in a compact WY-representation, where the elementary reflectors are in the arrays A, B and T. See Further Details section.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | ident | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | k | |||
| real(kind=sp), | intent(in) | :: | t(ldt,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldt | |||
| real(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=sp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| real(kind=sp), | intent(out) | :: | work(ldwork,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldwork |
ZLARFB_GETT applies a complex Householder block reflector H from the left to a complex (K+M)-by-N "triangular-pentagonal" matrix composed of two block matrices: an upper trapezoidal K-by-N matrix A stored in the array A, and a rectangular M-by-(N-K) matrix B, stored in the array B. The block reflector H is stored in a compact WY-representation, where the elementary reflectors are in the arrays A, B and T. See Further Details section.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | ident | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | k | |||
| complex(kind=dp), | intent(in) | :: | t(ldt,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldt | |||
| complex(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=dp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| complex(kind=dp), | intent(out) | :: | work(ldwork,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldwork |
LARFG generates a complex elementary reflector H of order n, such that HH * ( alpha ) = ( beta ), HH * H = I. ( x ) ( 0 ) where alpha and beta are scalars, with beta real, and x is an (n-1)-element complex vector. H is represented in the form H = I - tau * ( 1 ) * ( 1 v**H ) , ( v ) where tau is a complex scalar and v is a complex (n-1)-element vector. Note that H is not hermitian. If the elements of x are all zero and alpha is real, then tau = 0 and H is taken to be the unit matrix. Otherwise 1 <= real(tau) <= 2 and abs(tau-1) <= 1 .
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=sp), | intent(inout) | :: | alpha | |||
| complex(kind=sp), | intent(inout) | :: | x(*) | |||
| integer(kind=ilp), | intent(in) | :: | incx | |||
| complex(kind=sp), | intent(out) | :: | tau |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=dp), | intent(inout) | :: | alpha | |||
| real(kind=dp), | intent(inout) | :: | x(*) | |||
| integer(kind=ilp), | intent(in) | :: | incx | |||
| real(kind=dp), | intent(out) | :: | tau |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=sp), | intent(inout) | :: | alpha | |||
| real(kind=sp), | intent(inout) | :: | x(*) | |||
| integer(kind=ilp), | intent(in) | :: | incx | |||
| real(kind=sp), | intent(out) | :: | tau |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=dp), | intent(inout) | :: | alpha | |||
| complex(kind=dp), | intent(inout) | :: | x(*) | |||
| integer(kind=ilp), | intent(in) | :: | incx | |||
| complex(kind=dp), | intent(out) | :: | tau |
CLARFG generates a complex elementary reflector H of order n, such that HH * ( alpha ) = ( beta ), HH * H = I. ( x ) ( 0 ) where alpha and beta are scalars, with beta real, and x is an (n-1)-element complex vector. H is represented in the form H = I - tau * ( 1 ) * ( 1 v**H ) , ( v ) where tau is a complex scalar and v is a complex (n-1)-element vector. Note that H is not hermitian. If the elements of x are all zero and alpha is real, then tau = 0 and H is taken to be the unit matrix. Otherwise 1 <= real(tau) <= 2 and abs(tau-1) <= 1 .
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=sp), | intent(inout) | :: | alpha | |||
| complex(kind=sp), | intent(inout) | :: | x(*) | |||
| integer(kind=ilp), | intent(in) | :: | incx | |||
| complex(kind=sp), | intent(out) | :: | tau |
DLARFG generates a real elementary reflector H of order n, such that H * ( alpha ) = ( beta ), HT * H = I. ( x ) ( 0 ) where alpha and beta are scalars, and x is an (n-1)-element real vector. H is represented in the form H = I - tau * ( 1 ) * ( 1 vT ) , ( v ) where tau is a real scalar and v is a real (n-1)-element vector. If the elements of x are all zero, then tau = 0 and H is taken to be the unit matrix. Otherwise 1 <= tau <= 2.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=dp), | intent(inout) | :: | alpha | |||
| real(kind=dp), | intent(inout) | :: | x(*) | |||
| integer(kind=ilp), | intent(in) | :: | incx | |||
| real(kind=dp), | intent(out) | :: | tau |
SLARFG generates a real elementary reflector H of order n, such that H * ( alpha ) = ( beta ), HT * H = I. ( x ) ( 0 ) where alpha and beta are scalars, and x is an (n-1)-element real vector. H is represented in the form H = I - tau * ( 1 ) * ( 1 vT ) , ( v ) where tau is a real scalar and v is a real (n-1)-element vector. If the elements of x are all zero, then tau = 0 and H is taken to be the unit matrix. Otherwise 1 <= tau <= 2.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=sp), | intent(inout) | :: | alpha | |||
| real(kind=sp), | intent(inout) | :: | x(*) | |||
| integer(kind=ilp), | intent(in) | :: | incx | |||
| real(kind=sp), | intent(out) | :: | tau |
ZLARFG generates a complex elementary reflector H of order n, such that HH * ( alpha ) = ( beta ), HH * H = I. ( x ) ( 0 ) where alpha and beta are scalars, with beta real, and x is an (n-1)-element complex vector. H is represented in the form H = I - tau * ( 1 ) * ( 1 v**H ) , ( v ) where tau is a complex scalar and v is a complex (n-1)-element vector. Note that H is not hermitian. If the elements of x are all zero and alpha is real, then tau = 0 and H is taken to be the unit matrix. Otherwise 1 <= real(tau) <= 2 and abs(tau-1) <= 1 .
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=dp), | intent(inout) | :: | alpha | |||
| complex(kind=dp), | intent(inout) | :: | x(*) | |||
| integer(kind=ilp), | intent(in) | :: | incx | |||
| complex(kind=dp), | intent(out) | :: | tau |
LARFGP generates a complex elementary reflector H of order n, such that HH * ( alpha ) = ( beta ), HH * H = I. ( x ) ( 0 ) where alpha and beta are scalars, beta is real and non-negative, and x is an (n-1)-element complex vector. H is represented in the form H = I - tau * ( 1 ) * ( 1 v**H ) , ( v ) where tau is a complex scalar and v is a complex (n-1)-element vector. Note that H is not hermitian. If the elements of x are all zero and alpha is real, then tau = 0 and H is taken to be the unit matrix.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=sp), | intent(inout) | :: | alpha | |||
| complex(kind=sp), | intent(inout) | :: | x(*) | |||
| integer(kind=ilp), | intent(in) | :: | incx | |||
| complex(kind=sp), | intent(out) | :: | tau |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=dp), | intent(inout) | :: | alpha | |||
| real(kind=dp), | intent(inout) | :: | x(*) | |||
| integer(kind=ilp), | intent(in) | :: | incx | |||
| real(kind=dp), | intent(out) | :: | tau |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=sp), | intent(inout) | :: | alpha | |||
| real(kind=sp), | intent(inout) | :: | x(*) | |||
| integer(kind=ilp), | intent(in) | :: | incx | |||
| real(kind=sp), | intent(out) | :: | tau |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=dp), | intent(inout) | :: | alpha | |||
| complex(kind=dp), | intent(inout) | :: | x(*) | |||
| integer(kind=ilp), | intent(in) | :: | incx | |||
| complex(kind=dp), | intent(out) | :: | tau |
CLARFGP generates a complex elementary reflector H of order n, such that HH * ( alpha ) = ( beta ), HH * H = I. ( x ) ( 0 ) where alpha and beta are scalars, beta is real and non-negative, and x is an (n-1)-element complex vector. H is represented in the form H = I - tau * ( 1 ) * ( 1 v**H ) , ( v ) where tau is a complex scalar and v is a complex (n-1)-element vector. Note that H is not hermitian. If the elements of x are all zero and alpha is real, then tau = 0 and H is taken to be the unit matrix.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=sp), | intent(inout) | :: | alpha | |||
| complex(kind=sp), | intent(inout) | :: | x(*) | |||
| integer(kind=ilp), | intent(in) | :: | incx | |||
| complex(kind=sp), | intent(out) | :: | tau |
DLARFGP generates a real elementary reflector H of order n, such that H * ( alpha ) = ( beta ), HT * H = I. ( x ) ( 0 ) where alpha and beta are scalars, beta is non-negative, and x is an (n-1)-element real vector. H is represented in the form H = I - tau * ( 1 ) * ( 1 vT ) , ( v ) where tau is a real scalar and v is a real (n-1)-element vector. If the elements of x are all zero, then tau = 0 and H is taken to be the unit matrix.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=dp), | intent(inout) | :: | alpha | |||
| real(kind=dp), | intent(inout) | :: | x(*) | |||
| integer(kind=ilp), | intent(in) | :: | incx | |||
| real(kind=dp), | intent(out) | :: | tau |
SLARFGP generates a real elementary reflector H of order n, such that H * ( alpha ) = ( beta ), HT * H = I. ( x ) ( 0 ) where alpha and beta are scalars, beta is non-negative, and x is an (n-1)-element real vector. H is represented in the form H = I - tau * ( 1 ) * ( 1 vT ) , ( v ) where tau is a real scalar and v is a real (n-1)-element vector. If the elements of x are all zero, then tau = 0 and H is taken to be the unit matrix.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=sp), | intent(inout) | :: | alpha | |||
| real(kind=sp), | intent(inout) | :: | x(*) | |||
| integer(kind=ilp), | intent(in) | :: | incx | |||
| real(kind=sp), | intent(out) | :: | tau |
ZLARFGP generates a complex elementary reflector H of order n, such that HH * ( alpha ) = ( beta ), HH * H = I. ( x ) ( 0 ) where alpha and beta are scalars, beta is real and non-negative, and x is an (n-1)-element complex vector. H is represented in the form H = I - tau * ( 1 ) * ( 1 v**H ) , ( v ) where tau is a complex scalar and v is a complex (n-1)-element vector. Note that H is not hermitian. If the elements of x are all zero and alpha is real, then tau = 0 and H is taken to be the unit matrix.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=dp), | intent(inout) | :: | alpha | |||
| complex(kind=dp), | intent(inout) | :: | x(*) | |||
| integer(kind=ilp), | intent(in) | :: | incx | |||
| complex(kind=dp), | intent(out) | :: | tau |
LARFT forms the triangular factor T of a complex block reflector H of order n, which is defined as a product of k elementary reflectors. If DIRECT = 'F', H = H(1) H(2) . . . H(k) and T is upper triangular; If DIRECT = 'B', H = H(k) . . . H(2) H(1) and T is lower triangular. If STOREV = 'C', the vector which defines the elementary reflector H(i) is stored in the i-th column of the array V, and H = I - V * T * VH If STOREV = 'R', the vector which defines the elementary reflector H(i) is stored in the i-th row of the array V, and H = I - VH * T * V
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | direct | |||
| character, | intent(in) | :: | storev | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | k | |||
| complex(kind=sp), | intent(in) | :: | v(ldv,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldv | |||
| complex(kind=sp), | intent(in) | :: | tau(*) | |||
| complex(kind=sp), | intent(out) | :: | t(ldt,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldt |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | direct | |||
| character, | intent(in) | :: | storev | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | k | |||
| real(kind=dp), | intent(in) | :: | v(ldv,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldv | |||
| real(kind=dp), | intent(in) | :: | tau(*) | |||
| real(kind=dp), | intent(out) | :: | t(ldt,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldt |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | direct | |||
| character, | intent(in) | :: | storev | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | k | |||
| real(kind=sp), | intent(in) | :: | v(ldv,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldv | |||
| real(kind=sp), | intent(in) | :: | tau(*) | |||
| real(kind=sp), | intent(out) | :: | t(ldt,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldt |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | direct | |||
| character, | intent(in) | :: | storev | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | k | |||
| complex(kind=dp), | intent(in) | :: | v(ldv,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldv | |||
| complex(kind=dp), | intent(in) | :: | tau(*) | |||
| complex(kind=dp), | intent(out) | :: | t(ldt,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldt |
CLARFT forms the triangular factor T of a complex block reflector H of order n, which is defined as a product of k elementary reflectors. If DIRECT = 'F', H = H(1) H(2) . . . H(k) and T is upper triangular; If DIRECT = 'B', H = H(k) . . . H(2) H(1) and T is lower triangular. If STOREV = 'C', the vector which defines the elementary reflector H(i) is stored in the i-th column of the array V, and H = I - V * T * VH If STOREV = 'R', the vector which defines the elementary reflector H(i) is stored in the i-th row of the array V, and H = I - VH * T * V
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | direct | |||
| character, | intent(in) | :: | storev | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | k | |||
| complex(kind=sp), | intent(in) | :: | v(ldv,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldv | |||
| complex(kind=sp), | intent(in) | :: | tau(*) | |||
| complex(kind=sp), | intent(out) | :: | t(ldt,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldt |
DLARFT forms the triangular factor T of a real block reflector H of order n, which is defined as a product of k elementary reflectors. If DIRECT = 'F', H = H(1) H(2) . . . H(k) and T is upper triangular; If DIRECT = 'B', H = H(k) . . . H(2) H(1) and T is lower triangular. If STOREV = 'C', the vector which defines the elementary reflector H(i) is stored in the i-th column of the array V, and H = I - V * T * VT If STOREV = 'R', the vector which defines the elementary reflector H(i) is stored in the i-th row of the array V, and H = I - VT * T * V
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | direct | |||
| character, | intent(in) | :: | storev | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | k | |||
| real(kind=dp), | intent(in) | :: | v(ldv,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldv | |||
| real(kind=dp), | intent(in) | :: | tau(*) | |||
| real(kind=dp), | intent(out) | :: | t(ldt,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldt |
SLARFT forms the triangular factor T of a real block reflector H of order n, which is defined as a product of k elementary reflectors. If DIRECT = 'F', H = H(1) H(2) . . . H(k) and T is upper triangular; If DIRECT = 'B', H = H(k) . . . H(2) H(1) and T is lower triangular. If STOREV = 'C', the vector which defines the elementary reflector H(i) is stored in the i-th column of the array V, and H = I - V * T * VT If STOREV = 'R', the vector which defines the elementary reflector H(i) is stored in the i-th row of the array V, and H = I - VT * T * V
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | direct | |||
| character, | intent(in) | :: | storev | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | k | |||
| real(kind=sp), | intent(in) | :: | v(ldv,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldv | |||
| real(kind=sp), | intent(in) | :: | tau(*) | |||
| real(kind=sp), | intent(out) | :: | t(ldt,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldt |
ZLARFT forms the triangular factor T of a complex block reflector H of order n, which is defined as a product of k elementary reflectors. If DIRECT = 'F', H = H(1) H(2) . . . H(k) and T is upper triangular; If DIRECT = 'B', H = H(k) . . . H(2) H(1) and T is lower triangular. If STOREV = 'C', the vector which defines the elementary reflector H(i) is stored in the i-th column of the array V, and H = I - V * T * VH If STOREV = 'R', the vector which defines the elementary reflector H(i) is stored in the i-th row of the array V, and H = I - VH * T * V
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | direct | |||
| character, | intent(in) | :: | storev | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | k | |||
| complex(kind=dp), | intent(in) | :: | v(ldv,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldv | |||
| complex(kind=dp), | intent(in) | :: | tau(*) | |||
| complex(kind=dp), | intent(out) | :: | t(ldt,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldt |
LARFY applies an elementary reflector, or Householder matrix, H, to an n x n Hermitian matrix C, from both the left and the right. H is represented in the form H = I - tau * v * v' where tau is a scalar and v is a vector. If tau is zero, then H is taken to be the unit matrix.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=sp), | intent(in) | :: | v(*) | |||
| integer(kind=ilp), | intent(in) | :: | incv | |||
| complex(kind=sp), | intent(in) | :: | tau | |||
| complex(kind=sp), | intent(inout) | :: | c(ldc,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldc | |||
| complex(kind=sp), | intent(out) | :: | work(*) |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=dp), | intent(in) | :: | v(*) | |||
| integer(kind=ilp), | intent(in) | :: | incv | |||
| real(kind=dp), | intent(in) | :: | tau | |||
| real(kind=dp), | intent(inout) | :: | c(ldc,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldc | |||
| real(kind=dp), | intent(out) | :: | work(*) |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=sp), | intent(in) | :: | v(*) | |||
| integer(kind=ilp), | intent(in) | :: | incv | |||
| real(kind=sp), | intent(in) | :: | tau | |||
| real(kind=sp), | intent(inout) | :: | c(ldc,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldc | |||
| real(kind=sp), | intent(out) | :: | work(*) |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=dp), | intent(in) | :: | v(*) | |||
| integer(kind=ilp), | intent(in) | :: | incv | |||
| complex(kind=dp), | intent(in) | :: | tau | |||
| complex(kind=dp), | intent(inout) | :: | c(ldc,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldc | |||
| complex(kind=dp), | intent(out) | :: | work(*) |
CLARFY applies an elementary reflector, or Householder matrix, H, to an n x n Hermitian matrix C, from both the left and the right. H is represented in the form H = I - tau * v * v' where tau is a scalar and v is a vector. If tau is zero, then H is taken to be the unit matrix.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=sp), | intent(in) | :: | v(*) | |||
| integer(kind=ilp), | intent(in) | :: | incv | |||
| complex(kind=sp), | intent(in) | :: | tau | |||
| complex(kind=sp), | intent(inout) | :: | c(ldc,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldc | |||
| complex(kind=sp), | intent(out) | :: | work(*) |
DLARFY applies an elementary reflector, or Householder matrix, H, to an n x n symmetric matrix C, from both the left and the right. H is represented in the form H = I - tau * v * v' where tau is a scalar and v is a vector. If tau is zero, then H is taken to be the unit matrix.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=dp), | intent(in) | :: | v(*) | |||
| integer(kind=ilp), | intent(in) | :: | incv | |||
| real(kind=dp), | intent(in) | :: | tau | |||
| real(kind=dp), | intent(inout) | :: | c(ldc,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldc | |||
| real(kind=dp), | intent(out) | :: | work(*) |
SLARFY applies an elementary reflector, or Householder matrix, H, to an n x n symmetric matrix C, from both the left and the right. H is represented in the form H = I - tau * v * v' where tau is a scalar and v is a vector. If tau is zero, then H is taken to be the unit matrix.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=sp), | intent(in) | :: | v(*) | |||
| integer(kind=ilp), | intent(in) | :: | incv | |||
| real(kind=sp), | intent(in) | :: | tau | |||
| real(kind=sp), | intent(inout) | :: | c(ldc,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldc | |||
| real(kind=sp), | intent(out) | :: | work(*) |
ZLARFY applies an elementary reflector, or Householder matrix, H, to an n x n Hermitian matrix C, from both the left and the right. H is represented in the form H = I - tau * v * v' where tau is a scalar and v is a vector. If tau is zero, then H is taken to be the unit matrix.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=dp), | intent(in) | :: | v(*) | |||
| integer(kind=ilp), | intent(in) | :: | incv | |||
| complex(kind=dp), | intent(in) | :: | tau | |||
| complex(kind=dp), | intent(inout) | :: | c(ldc,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldc | |||
| complex(kind=dp), | intent(out) | :: | work(*) |
LARGV generates a vector of complex plane rotations with real cosines, determined by elements of the complex vectors x and y. For i = 1,2,...,n ( c(i) s(i) ) ( x(i) ) = ( r(i) ) ( -conjg(s(i)) c(i) ) ( y(i) ) = ( 0 ) where c(i)2 + ABS(s(i))2 = 1 The following conventions are used (these are the same as in CLARTG, but differ from the BLAS1 routine CROTG): If y(i)=0, then c(i)=1 and s(i)=0. If x(i)=0, then c(i)=0 and s(i) is chosen so that r(i) is real.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=sp), | intent(inout) | :: | x(*) | |||
| integer(kind=ilp), | intent(in) | :: | incx | |||
| complex(kind=sp), | intent(inout) | :: | y(*) | |||
| integer(kind=ilp), | intent(in) | :: | incy | |||
| real(kind=sp), | intent(out) | :: | c(*) | |||
| integer(kind=ilp), | intent(in) | :: | incc |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=dp), | intent(inout) | :: | x(*) | |||
| integer(kind=ilp), | intent(in) | :: | incx | |||
| real(kind=dp), | intent(inout) | :: | y(*) | |||
| integer(kind=ilp), | intent(in) | :: | incy | |||
| real(kind=dp), | intent(out) | :: | c(*) | |||
| integer(kind=ilp), | intent(in) | :: | incc |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=sp), | intent(inout) | :: | x(*) | |||
| integer(kind=ilp), | intent(in) | :: | incx | |||
| real(kind=sp), | intent(inout) | :: | y(*) | |||
| integer(kind=ilp), | intent(in) | :: | incy | |||
| real(kind=sp), | intent(out) | :: | c(*) | |||
| integer(kind=ilp), | intent(in) | :: | incc |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=dp), | intent(inout) | :: | x(*) | |||
| integer(kind=ilp), | intent(in) | :: | incx | |||
| complex(kind=dp), | intent(inout) | :: | y(*) | |||
| integer(kind=ilp), | intent(in) | :: | incy | |||
| real(kind=dp), | intent(out) | :: | c(*) | |||
| integer(kind=ilp), | intent(in) | :: | incc |
CLARGV generates a vector of complex plane rotations with real cosines, determined by elements of the complex vectors x and y. For i = 1,2,...,n ( c(i) s(i) ) ( x(i) ) = ( r(i) ) ( -conjg(s(i)) c(i) ) ( y(i) ) = ( 0 ) where c(i)2 + ABS(s(i))2 = 1 The following conventions are used (these are the same as in CLARTG, but differ from the BLAS1 routine CROTG): If y(i)=0, then c(i)=1 and s(i)=0. If x(i)=0, then c(i)=0 and s(i) is chosen so that r(i) is real.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=sp), | intent(inout) | :: | x(*) | |||
| integer(kind=ilp), | intent(in) | :: | incx | |||
| complex(kind=sp), | intent(inout) | :: | y(*) | |||
| integer(kind=ilp), | intent(in) | :: | incy | |||
| real(kind=sp), | intent(out) | :: | c(*) | |||
| integer(kind=ilp), | intent(in) | :: | incc |
DLARGV generates a vector of real plane rotations, determined by elements of the real vectors x and y. For i = 1,2,...,n ( c(i) s(i) ) ( x(i) ) = ( a(i) ) ( -s(i) c(i) ) ( y(i) ) = ( 0 )
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=dp), | intent(inout) | :: | x(*) | |||
| integer(kind=ilp), | intent(in) | :: | incx | |||
| real(kind=dp), | intent(inout) | :: | y(*) | |||
| integer(kind=ilp), | intent(in) | :: | incy | |||
| real(kind=dp), | intent(out) | :: | c(*) | |||
| integer(kind=ilp), | intent(in) | :: | incc |
SLARGV generates a vector of real plane rotations, determined by elements of the real vectors x and y. For i = 1,2,...,n ( c(i) s(i) ) ( x(i) ) = ( a(i) ) ( -s(i) c(i) ) ( y(i) ) = ( 0 )
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=sp), | intent(inout) | :: | x(*) | |||
| integer(kind=ilp), | intent(in) | :: | incx | |||
| real(kind=sp), | intent(inout) | :: | y(*) | |||
| integer(kind=ilp), | intent(in) | :: | incy | |||
| real(kind=sp), | intent(out) | :: | c(*) | |||
| integer(kind=ilp), | intent(in) | :: | incc |
ZLARGV generates a vector of complex plane rotations with real cosines, determined by elements of the complex vectors x and y. For i = 1,2,...,n ( c(i) s(i) ) ( x(i) ) = ( r(i) ) ( -conjg(s(i)) c(i) ) ( y(i) ) = ( 0 ) where c(i)2 + ABS(s(i))2 = 1 The following conventions are used (these are the same as in ZLARTG, but differ from the BLAS1 routine ZROTG): If y(i)=0, then c(i)=1 and s(i)=0. If x(i)=0, then c(i)=0 and s(i) is chosen so that r(i) is real.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=dp), | intent(inout) | :: | x(*) | |||
| integer(kind=ilp), | intent(in) | :: | incx | |||
| complex(kind=dp), | intent(inout) | :: | y(*) | |||
| integer(kind=ilp), | intent(in) | :: | incy | |||
| real(kind=dp), | intent(out) | :: | c(*) | |||
| integer(kind=ilp), | intent(in) | :: | incc |
LARNV returns a vector of n random complex numbers from a uniform or normal distribution.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | idist | |||
| integer(kind=ilp), | intent(inout) | :: | iseed(4) | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=sp), | intent(out) | :: | x(*) |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | idist | |||
| integer(kind=ilp), | intent(inout) | :: | iseed(4) | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=dp), | intent(out) | :: | x(*) |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | idist | |||
| integer(kind=ilp), | intent(inout) | :: | iseed(4) | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=sp), | intent(out) | :: | x(*) |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | idist | |||
| integer(kind=ilp), | intent(inout) | :: | iseed(4) | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=dp), | intent(out) | :: | x(*) |
CLARNV returns a vector of n random complex numbers from a uniform or normal distribution.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | idist | |||
| integer(kind=ilp), | intent(inout) | :: | iseed(4) | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=sp), | intent(out) | :: | x(*) |
DLARNV returns a vector of n random real numbers from a uniform or normal distribution.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | idist | |||
| integer(kind=ilp), | intent(inout) | :: | iseed(4) | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=dp), | intent(out) | :: | x(*) |
SLARNV returns a vector of n random real numbers from a uniform or normal distribution.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | idist | |||
| integer(kind=ilp), | intent(inout) | :: | iseed(4) | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=sp), | intent(out) | :: | x(*) |
ZLARNV returns a vector of n random complex numbers from a uniform or normal distribution.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | idist | |||
| integer(kind=ilp), | intent(inout) | :: | iseed(4) | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=dp), | intent(out) | :: | x(*) |
Compute the splitting points with threshold SPLTOL. LARRA sets any "small" off-diagonal elements to zero.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=dp), | intent(in) | :: | d(*) | |||
| real(kind=dp), | intent(inout) | :: | e(*) | |||
| real(kind=dp), | intent(inout) | :: | e2(*) | |||
| real(kind=dp), | intent(in) | :: | spltol | |||
| real(kind=dp), | intent(in) | :: | tnrm | |||
| integer(kind=ilp), | intent(out) | :: | nsplit | |||
| integer(kind=ilp), | intent(out) | :: | isplit(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=sp), | intent(in) | :: | d(*) | |||
| real(kind=sp), | intent(inout) | :: | e(*) | |||
| real(kind=sp), | intent(inout) | :: | e2(*) | |||
| real(kind=sp), | intent(in) | :: | spltol | |||
| real(kind=sp), | intent(in) | :: | tnrm | |||
| integer(kind=ilp), | intent(out) | :: | nsplit | |||
| integer(kind=ilp), | intent(out) | :: | isplit(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
Compute the splitting points with threshold SPLTOL. DLARRA sets any "small" off-diagonal elements to zero.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=dp), | intent(in) | :: | d(*) | |||
| real(kind=dp), | intent(inout) | :: | e(*) | |||
| real(kind=dp), | intent(inout) | :: | e2(*) | |||
| real(kind=dp), | intent(in) | :: | spltol | |||
| real(kind=dp), | intent(in) | :: | tnrm | |||
| integer(kind=ilp), | intent(out) | :: | nsplit | |||
| integer(kind=ilp), | intent(out) | :: | isplit(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
Compute the splitting points with threshold SPLTOL. SLARRA sets any "small" off-diagonal elements to zero.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=sp), | intent(in) | :: | d(*) | |||
| real(kind=sp), | intent(inout) | :: | e(*) | |||
| real(kind=sp), | intent(inout) | :: | e2(*) | |||
| real(kind=sp), | intent(in) | :: | spltol | |||
| real(kind=sp), | intent(in) | :: | tnrm | |||
| integer(kind=ilp), | intent(out) | :: | nsplit | |||
| integer(kind=ilp), | intent(out) | :: | isplit(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
Given the relatively robust representation(RRR) L D L^T, LARRB: does "limited" bisection to refine the eigenvalues of L D L^T, W( IFIRST-OFFSET ) through W( ILAST-OFFSET ), to more accuracy. Initial guesses for these eigenvalues are input in W, the corresponding estimate of the error in these guesses and their gaps are input in WERR and WGAP, respectively. During bisection, intervals [left, right] are maintained by storing their mid-points and semi-widths in the arrays W and WERR respectively.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=dp), | intent(in) | :: | d(*) | |||
| real(kind=dp), | intent(in) | :: | lld(*) | |||
| integer(kind=ilp), | intent(in) | :: | ifirst | |||
| integer(kind=ilp), | intent(in) | :: | ilast | |||
| real(kind=dp), | intent(in) | :: | rtol1 | |||
| real(kind=dp), | intent(in) | :: | rtol2 | |||
| integer(kind=ilp), | intent(in) | :: | offset | |||
| real(kind=dp), | intent(inout) | :: | w(*) | |||
| real(kind=dp), | intent(inout) | :: | wgap(*) | |||
| real(kind=dp), | intent(inout) | :: | werr(*) | |||
| real(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | iwork(*) | |||
| real(kind=dp), | intent(in) | :: | pivmin | |||
| real(kind=dp), | intent(in) | :: | spdiam | |||
| integer(kind=ilp), | intent(in) | :: | twist | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=sp), | intent(in) | :: | d(*) | |||
| real(kind=sp), | intent(in) | :: | lld(*) | |||
| integer(kind=ilp), | intent(in) | :: | ifirst | |||
| integer(kind=ilp), | intent(in) | :: | ilast | |||
| real(kind=sp), | intent(in) | :: | rtol1 | |||
| real(kind=sp), | intent(in) | :: | rtol2 | |||
| integer(kind=ilp), | intent(in) | :: | offset | |||
| real(kind=sp), | intent(inout) | :: | w(*) | |||
| real(kind=sp), | intent(inout) | :: | wgap(*) | |||
| real(kind=sp), | intent(inout) | :: | werr(*) | |||
| real(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | iwork(*) | |||
| real(kind=sp), | intent(in) | :: | pivmin | |||
| real(kind=sp), | intent(in) | :: | spdiam | |||
| integer(kind=ilp), | intent(in) | :: | twist | |||
| integer(kind=ilp), | intent(out) | :: | info |
Given the relatively robust representation(RRR) L D L^T, DLARRB: does "limited" bisection to refine the eigenvalues of L D L^T, W( IFIRST-OFFSET ) through W( ILAST-OFFSET ), to more accuracy. Initial guesses for these eigenvalues are input in W, the corresponding estimate of the error in these guesses and their gaps are input in WERR and WGAP, respectively. During bisection, intervals [left, right] are maintained by storing their mid-points and semi-widths in the arrays W and WERR respectively.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=dp), | intent(in) | :: | d(*) | |||
| real(kind=dp), | intent(in) | :: | lld(*) | |||
| integer(kind=ilp), | intent(in) | :: | ifirst | |||
| integer(kind=ilp), | intent(in) | :: | ilast | |||
| real(kind=dp), | intent(in) | :: | rtol1 | |||
| real(kind=dp), | intent(in) | :: | rtol2 | |||
| integer(kind=ilp), | intent(in) | :: | offset | |||
| real(kind=dp), | intent(inout) | :: | w(*) | |||
| real(kind=dp), | intent(inout) | :: | wgap(*) | |||
| real(kind=dp), | intent(inout) | :: | werr(*) | |||
| real(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | iwork(*) | |||
| real(kind=dp), | intent(in) | :: | pivmin | |||
| real(kind=dp), | intent(in) | :: | spdiam | |||
| integer(kind=ilp), | intent(in) | :: | twist | |||
| integer(kind=ilp), | intent(out) | :: | info |
Given the relatively robust representation(RRR) L D L^T, SLARRB: does "limited" bisection to refine the eigenvalues of L D L^T, W( IFIRST-OFFSET ) through W( ILAST-OFFSET ), to more accuracy. Initial guesses for these eigenvalues are input in W, the corresponding estimate of the error in these guesses and their gaps are input in WERR and WGAP, respectively. During bisection, intervals [left, right] are maintained by storing their mid-points and semi-widths in the arrays W and WERR respectively.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=sp), | intent(in) | :: | d(*) | |||
| real(kind=sp), | intent(in) | :: | lld(*) | |||
| integer(kind=ilp), | intent(in) | :: | ifirst | |||
| integer(kind=ilp), | intent(in) | :: | ilast | |||
| real(kind=sp), | intent(in) | :: | rtol1 | |||
| real(kind=sp), | intent(in) | :: | rtol2 | |||
| integer(kind=ilp), | intent(in) | :: | offset | |||
| real(kind=sp), | intent(inout) | :: | w(*) | |||
| real(kind=sp), | intent(inout) | :: | wgap(*) | |||
| real(kind=sp), | intent(inout) | :: | werr(*) | |||
| real(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | iwork(*) | |||
| real(kind=sp), | intent(in) | :: | pivmin | |||
| real(kind=sp), | intent(in) | :: | spdiam | |||
| integer(kind=ilp), | intent(in) | :: | twist | |||
| integer(kind=ilp), | intent(out) | :: | info |
Find the number of eigenvalues of the symmetric tridiagonal matrix T that are in the interval (VL,VU] if JOBT = 'T', and of L D L^T if JOBT = 'L'.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | jobt | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=dp), | intent(in) | :: | vl | |||
| real(kind=dp), | intent(in) | :: | vu | |||
| real(kind=dp), | intent(in) | :: | d(*) | |||
| real(kind=dp), | intent(in) | :: | e(*) | |||
| real(kind=dp), | intent(in) | :: | pivmin | |||
| integer(kind=ilp), | intent(out) | :: | eigcnt | |||
| integer(kind=ilp), | intent(out) | :: | lcnt | |||
| integer(kind=ilp), | intent(out) | :: | rcnt | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | jobt | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=sp), | intent(in) | :: | vl | |||
| real(kind=sp), | intent(in) | :: | vu | |||
| real(kind=sp), | intent(in) | :: | d(*) | |||
| real(kind=sp), | intent(in) | :: | e(*) | |||
| real(kind=sp), | intent(in) | :: | pivmin | |||
| integer(kind=ilp), | intent(out) | :: | eigcnt | |||
| integer(kind=ilp), | intent(out) | :: | lcnt | |||
| integer(kind=ilp), | intent(out) | :: | rcnt | |||
| integer(kind=ilp), | intent(out) | :: | info |
Find the number of eigenvalues of the symmetric tridiagonal matrix T that are in the interval (VL,VU] if JOBT = 'T', and of L D L^T if JOBT = 'L'.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | jobt | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=dp), | intent(in) | :: | vl | |||
| real(kind=dp), | intent(in) | :: | vu | |||
| real(kind=dp), | intent(in) | :: | d(*) | |||
| real(kind=dp), | intent(in) | :: | e(*) | |||
| real(kind=dp), | intent(in) | :: | pivmin | |||
| integer(kind=ilp), | intent(out) | :: | eigcnt | |||
| integer(kind=ilp), | intent(out) | :: | lcnt | |||
| integer(kind=ilp), | intent(out) | :: | rcnt | |||
| integer(kind=ilp), | intent(out) | :: | info |
Find the number of eigenvalues of the symmetric tridiagonal matrix T that are in the interval (VL,VU] if JOBT = 'T', and of L D L^T if JOBT = 'L'.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | jobt | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=sp), | intent(in) | :: | vl | |||
| real(kind=sp), | intent(in) | :: | vu | |||
| real(kind=sp), | intent(in) | :: | d(*) | |||
| real(kind=sp), | intent(in) | :: | e(*) | |||
| real(kind=sp), | intent(in) | :: | pivmin | |||
| integer(kind=ilp), | intent(out) | :: | eigcnt | |||
| integer(kind=ilp), | intent(out) | :: | lcnt | |||
| integer(kind=ilp), | intent(out) | :: | rcnt | |||
| integer(kind=ilp), | intent(out) | :: | info |
LARRD computes the eigenvalues of a symmetric tridiagonal matrix T to suitable accuracy. This is an auxiliary code to be called from DSTEMR. The user may ask for all eigenvalues, all eigenvalues in the half-open interval (VL, VU], or the IL-th through IU-th eigenvalues. To avoid overflow, the matrix must be scaled so that its largest element is no greater than overflow(1/2) * underflow(1/4) in absolute value, and for greatest accuracy, it should not be much smaller than that. See W. Kahan "Accurate Eigenvalues of a Symmetric Tridiagonal Matrix", Report CS41, Computer Science Dept., Stanford University, July 21, 1966.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | range | |||
| character, | intent(in) | :: | order | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=dp), | intent(in) | :: | vl | |||
| real(kind=dp), | intent(in) | :: | vu | |||
| integer(kind=ilp), | intent(in) | :: | il | |||
| integer(kind=ilp), | intent(in) | :: | iu | |||
| real(kind=dp), | intent(in) | :: | gers(*) | |||
| real(kind=dp), | intent(in) | :: | reltol | |||
| real(kind=dp), | intent(in) | :: | d(*) | |||
| real(kind=dp), | intent(in) | :: | e(*) | |||
| real(kind=dp), | intent(in) | :: | e2(*) | |||
| real(kind=dp), | intent(in) | :: | pivmin | |||
| integer(kind=ilp), | intent(in) | :: | nsplit | |||
| integer(kind=ilp), | intent(in) | :: | isplit(*) | |||
| integer(kind=ilp), | intent(out) | :: | m | |||
| real(kind=dp), | intent(out) | :: | w(*) | |||
| real(kind=dp), | intent(out) | :: | werr(*) | |||
| real(kind=dp), | intent(out) | :: | wl | |||
| real(kind=dp), | intent(out) | :: | wu | |||
| integer(kind=ilp), | intent(out) | :: | iblock(*) | |||
| integer(kind=ilp), | intent(out) | :: | indexw(*) | |||
| real(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | iwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | range | |||
| character, | intent(in) | :: | order | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=sp), | intent(in) | :: | vl | |||
| real(kind=sp), | intent(in) | :: | vu | |||
| integer(kind=ilp), | intent(in) | :: | il | |||
| integer(kind=ilp), | intent(in) | :: | iu | |||
| real(kind=sp), | intent(in) | :: | gers(*) | |||
| real(kind=sp), | intent(in) | :: | reltol | |||
| real(kind=sp), | intent(in) | :: | d(*) | |||
| real(kind=sp), | intent(in) | :: | e(*) | |||
| real(kind=sp), | intent(in) | :: | e2(*) | |||
| real(kind=sp), | intent(in) | :: | pivmin | |||
| integer(kind=ilp), | intent(in) | :: | nsplit | |||
| integer(kind=ilp), | intent(in) | :: | isplit(*) | |||
| integer(kind=ilp), | intent(out) | :: | m | |||
| real(kind=sp), | intent(out) | :: | w(*) | |||
| real(kind=sp), | intent(out) | :: | werr(*) | |||
| real(kind=sp), | intent(out) | :: | wl | |||
| real(kind=sp), | intent(out) | :: | wu | |||
| integer(kind=ilp), | intent(out) | :: | iblock(*) | |||
| integer(kind=ilp), | intent(out) | :: | indexw(*) | |||
| real(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | iwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
DLARRD computes the eigenvalues of a symmetric tridiagonal matrix T to suitable accuracy. This is an auxiliary code to be called from DSTEMR. The user may ask for all eigenvalues, all eigenvalues in the half-open interval (VL, VU], or the IL-th through IU-th eigenvalues. To avoid overflow, the matrix must be scaled so that its largest element is no greater than overflow(1/2) * underflow(1/4) in absolute value, and for greatest accuracy, it should not be much smaller than that. See W. Kahan "Accurate Eigenvalues of a Symmetric Tridiagonal Matrix", Report CS41, Computer Science Dept., Stanford University, July 21, 1966.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | range | |||
| character, | intent(in) | :: | order | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=dp), | intent(in) | :: | vl | |||
| real(kind=dp), | intent(in) | :: | vu | |||
| integer(kind=ilp), | intent(in) | :: | il | |||
| integer(kind=ilp), | intent(in) | :: | iu | |||
| real(kind=dp), | intent(in) | :: | gers(*) | |||
| real(kind=dp), | intent(in) | :: | reltol | |||
| real(kind=dp), | intent(in) | :: | d(*) | |||
| real(kind=dp), | intent(in) | :: | e(*) | |||
| real(kind=dp), | intent(in) | :: | e2(*) | |||
| real(kind=dp), | intent(in) | :: | pivmin | |||
| integer(kind=ilp), | intent(in) | :: | nsplit | |||
| integer(kind=ilp), | intent(in) | :: | isplit(*) | |||
| integer(kind=ilp), | intent(out) | :: | m | |||
| real(kind=dp), | intent(out) | :: | w(*) | |||
| real(kind=dp), | intent(out) | :: | werr(*) | |||
| real(kind=dp), | intent(out) | :: | wl | |||
| real(kind=dp), | intent(out) | :: | wu | |||
| integer(kind=ilp), | intent(out) | :: | iblock(*) | |||
| integer(kind=ilp), | intent(out) | :: | indexw(*) | |||
| real(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | iwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
SLARRD computes the eigenvalues of a symmetric tridiagonal matrix T to suitable accuracy. This is an auxiliary code to be called from SSTEMR. The user may ask for all eigenvalues, all eigenvalues in the half-open interval (VL, VU], or the IL-th through IU-th eigenvalues. To avoid overflow, the matrix must be scaled so that its largest element is no greater than overflow(1/2) * underflow(1/4) in absolute value, and for greatest accuracy, it should not be much smaller than that. See W. Kahan "Accurate Eigenvalues of a Symmetric Tridiagonal Matrix", Report CS41, Computer Science Dept., Stanford University, July 21, 1966.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | range | |||
| character, | intent(in) | :: | order | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=sp), | intent(in) | :: | vl | |||
| real(kind=sp), | intent(in) | :: | vu | |||
| integer(kind=ilp), | intent(in) | :: | il | |||
| integer(kind=ilp), | intent(in) | :: | iu | |||
| real(kind=sp), | intent(in) | :: | gers(*) | |||
| real(kind=sp), | intent(in) | :: | reltol | |||
| real(kind=sp), | intent(in) | :: | d(*) | |||
| real(kind=sp), | intent(in) | :: | e(*) | |||
| real(kind=sp), | intent(in) | :: | e2(*) | |||
| real(kind=sp), | intent(in) | :: | pivmin | |||
| integer(kind=ilp), | intent(in) | :: | nsplit | |||
| integer(kind=ilp), | intent(in) | :: | isplit(*) | |||
| integer(kind=ilp), | intent(out) | :: | m | |||
| real(kind=sp), | intent(out) | :: | w(*) | |||
| real(kind=sp), | intent(out) | :: | werr(*) | |||
| real(kind=sp), | intent(out) | :: | wl | |||
| real(kind=sp), | intent(out) | :: | wu | |||
| integer(kind=ilp), | intent(out) | :: | iblock(*) | |||
| integer(kind=ilp), | intent(out) | :: | indexw(*) | |||
| real(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | iwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
To find the desired eigenvalues of a given real symmetric tridiagonal matrix T, LARRE: sets any "small" off-diagonal elements to zero, and for each unreduced block T_i, it finds (a) a suitable shift at one end of the block's spectrum, (b) the base representation, T_i - sigma_i I = L_i D_i L_i^T, and (c) eigenvalues of each L_i D_i L_i^T. The representations and eigenvalues found are then used by DSTEMR to compute the eigenvectors of T. The accuracy varies depending on whether bisection is used to find a few eigenvalues or the dqds algorithm (subroutine DLASQ2) to conpute all and then discard any unwanted one. As an added benefit, LARRE also outputs the n Gerschgorin intervals for the matrices L_i D_i L_i^T.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | range | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=dp), | intent(inout) | :: | vl | |||
| real(kind=dp), | intent(inout) | :: | vu | |||
| integer(kind=ilp), | intent(in) | :: | il | |||
| integer(kind=ilp), | intent(in) | :: | iu | |||
| real(kind=dp), | intent(inout) | :: | d(*) | |||
| real(kind=dp), | intent(inout) | :: | e(*) | |||
| real(kind=dp), | intent(inout) | :: | e2(*) | |||
| real(kind=dp), | intent(in) | :: | rtol1 | |||
| real(kind=dp), | intent(in) | :: | rtol2 | |||
| real(kind=dp), | intent(in) | :: | spltol | |||
| integer(kind=ilp), | intent(out) | :: | nsplit | |||
| integer(kind=ilp), | intent(out) | :: | isplit(*) | |||
| integer(kind=ilp), | intent(out) | :: | m | |||
| real(kind=dp), | intent(out) | :: | w(*) | |||
| real(kind=dp), | intent(out) | :: | werr(*) | |||
| real(kind=dp), | intent(out) | :: | wgap(*) | |||
| integer(kind=ilp), | intent(out) | :: | iblock(*) | |||
| integer(kind=ilp), | intent(out) | :: | indexw(*) | |||
| real(kind=dp), | intent(out) | :: | gers(*) | |||
| real(kind=dp), | intent(out) | :: | pivmin | |||
| real(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | iwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | range | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=sp), | intent(inout) | :: | vl | |||
| real(kind=sp), | intent(inout) | :: | vu | |||
| integer(kind=ilp), | intent(in) | :: | il | |||
| integer(kind=ilp), | intent(in) | :: | iu | |||
| real(kind=sp), | intent(inout) | :: | d(*) | |||
| real(kind=sp), | intent(inout) | :: | e(*) | |||
| real(kind=sp), | intent(inout) | :: | e2(*) | |||
| real(kind=sp), | intent(in) | :: | rtol1 | |||
| real(kind=sp), | intent(in) | :: | rtol2 | |||
| real(kind=sp), | intent(in) | :: | spltol | |||
| integer(kind=ilp), | intent(out) | :: | nsplit | |||
| integer(kind=ilp), | intent(out) | :: | isplit(*) | |||
| integer(kind=ilp), | intent(out) | :: | m | |||
| real(kind=sp), | intent(out) | :: | w(*) | |||
| real(kind=sp), | intent(out) | :: | werr(*) | |||
| real(kind=sp), | intent(out) | :: | wgap(*) | |||
| integer(kind=ilp), | intent(out) | :: | iblock(*) | |||
| integer(kind=ilp), | intent(out) | :: | indexw(*) | |||
| real(kind=sp), | intent(out) | :: | gers(*) | |||
| real(kind=sp), | intent(out) | :: | pivmin | |||
| real(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | iwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
To find the desired eigenvalues of a given real symmetric tridiagonal matrix T, DLARRE: sets any "small" off-diagonal elements to zero, and for each unreduced block T_i, it finds (a) a suitable shift at one end of the block's spectrum, (b) the base representation, T_i - sigma_i I = L_i D_i L_i^T, and (c) eigenvalues of each L_i D_i L_i^T. The representations and eigenvalues found are then used by DSTEMR to compute the eigenvectors of T. The accuracy varies depending on whether bisection is used to find a few eigenvalues or the dqds algorithm (subroutine DLASQ2) to conpute all and then discard any unwanted one. As an added benefit, DLARRE also outputs the n Gerschgorin intervals for the matrices L_i D_i L_i^T.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | range | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=dp), | intent(inout) | :: | vl | |||
| real(kind=dp), | intent(inout) | :: | vu | |||
| integer(kind=ilp), | intent(in) | :: | il | |||
| integer(kind=ilp), | intent(in) | :: | iu | |||
| real(kind=dp), | intent(inout) | :: | d(*) | |||
| real(kind=dp), | intent(inout) | :: | e(*) | |||
| real(kind=dp), | intent(inout) | :: | e2(*) | |||
| real(kind=dp), | intent(in) | :: | rtol1 | |||
| real(kind=dp), | intent(in) | :: | rtol2 | |||
| real(kind=dp), | intent(in) | :: | spltol | |||
| integer(kind=ilp), | intent(out) | :: | nsplit | |||
| integer(kind=ilp), | intent(out) | :: | isplit(*) | |||
| integer(kind=ilp), | intent(out) | :: | m | |||
| real(kind=dp), | intent(out) | :: | w(*) | |||
| real(kind=dp), | intent(out) | :: | werr(*) | |||
| real(kind=dp), | intent(out) | :: | wgap(*) | |||
| integer(kind=ilp), | intent(out) | :: | iblock(*) | |||
| integer(kind=ilp), | intent(out) | :: | indexw(*) | |||
| real(kind=dp), | intent(out) | :: | gers(*) | |||
| real(kind=dp), | intent(out) | :: | pivmin | |||
| real(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | iwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
To find the desired eigenvalues of a given real symmetric tridiagonal matrix T, SLARRE: sets any "small" off-diagonal elements to zero, and for each unreduced block T_i, it finds (a) a suitable shift at one end of the block's spectrum, (b) the base representation, T_i - sigma_i I = L_i D_i L_i^T, and (c) eigenvalues of each L_i D_i L_i^T. The representations and eigenvalues found are then used by SSTEMR to compute the eigenvectors of T. The accuracy varies depending on whether bisection is used to find a few eigenvalues or the dqds algorithm (subroutine SLASQ2) to conpute all and then discard any unwanted one. As an added benefit, SLARRE also outputs the n Gerschgorin intervals for the matrices L_i D_i L_i^T.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | range | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=sp), | intent(inout) | :: | vl | |||
| real(kind=sp), | intent(inout) | :: | vu | |||
| integer(kind=ilp), | intent(in) | :: | il | |||
| integer(kind=ilp), | intent(in) | :: | iu | |||
| real(kind=sp), | intent(inout) | :: | d(*) | |||
| real(kind=sp), | intent(inout) | :: | e(*) | |||
| real(kind=sp), | intent(inout) | :: | e2(*) | |||
| real(kind=sp), | intent(in) | :: | rtol1 | |||
| real(kind=sp), | intent(in) | :: | rtol2 | |||
| real(kind=sp), | intent(in) | :: | spltol | |||
| integer(kind=ilp), | intent(out) | :: | nsplit | |||
| integer(kind=ilp), | intent(out) | :: | isplit(*) | |||
| integer(kind=ilp), | intent(out) | :: | m | |||
| real(kind=sp), | intent(out) | :: | w(*) | |||
| real(kind=sp), | intent(out) | :: | werr(*) | |||
| real(kind=sp), | intent(out) | :: | wgap(*) | |||
| integer(kind=ilp), | intent(out) | :: | iblock(*) | |||
| integer(kind=ilp), | intent(out) | :: | indexw(*) | |||
| real(kind=sp), | intent(out) | :: | gers(*) | |||
| real(kind=sp), | intent(out) | :: | pivmin | |||
| real(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | iwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
Given the initial representation L D L^T and its cluster of close eigenvalues (in a relative measure), W( CLSTRT ), W( CLSTRT+1 ), ... W( CLEND ), LARRF: finds a new relatively robust representation L D L^T - SIGMA I = L(+) D(+) L(+)^T such that at least one of the eigenvalues of L(+) D(+) L(+)^T is relatively isolated.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=dp), | intent(in) | :: | d(*) | |||
| real(kind=dp), | intent(in) | :: | l(*) | |||
| real(kind=dp), | intent(in) | :: | ld(*) | |||
| integer(kind=ilp), | intent(in) | :: | clstrt | |||
| integer(kind=ilp), | intent(in) | :: | clend | |||
| real(kind=dp), | intent(in) | :: | w(*) | |||
| real(kind=dp), | intent(inout) | :: | wgap(*) | |||
| real(kind=dp), | intent(in) | :: | werr(*) | |||
| real(kind=dp), | intent(in) | :: | spdiam | |||
| real(kind=dp), | intent(in) | :: | clgapl | |||
| real(kind=dp), | intent(in) | :: | clgapr | |||
| real(kind=dp), | intent(in) | :: | pivmin | |||
| real(kind=dp), | intent(out) | :: | sigma | |||
| real(kind=dp), | intent(out) | :: | dplus(*) | |||
| real(kind=dp), | intent(out) | :: | lplus(*) | |||
| real(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=sp), | intent(in) | :: | d(*) | |||
| real(kind=sp), | intent(in) | :: | l(*) | |||
| real(kind=sp), | intent(in) | :: | ld(*) | |||
| integer(kind=ilp), | intent(in) | :: | clstrt | |||
| integer(kind=ilp), | intent(in) | :: | clend | |||
| real(kind=sp), | intent(in) | :: | w(*) | |||
| real(kind=sp), | intent(inout) | :: | wgap(*) | |||
| real(kind=sp), | intent(in) | :: | werr(*) | |||
| real(kind=sp), | intent(in) | :: | spdiam | |||
| real(kind=sp), | intent(in) | :: | clgapl | |||
| real(kind=sp), | intent(in) | :: | clgapr | |||
| real(kind=sp), | intent(in) | :: | pivmin | |||
| real(kind=sp), | intent(out) | :: | sigma | |||
| real(kind=sp), | intent(out) | :: | dplus(*) | |||
| real(kind=sp), | intent(out) | :: | lplus(*) | |||
| real(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
Given the initial representation L D L^T and its cluster of close eigenvalues (in a relative measure), W( CLSTRT ), W( CLSTRT+1 ), ... W( CLEND ), DLARRF: finds a new relatively robust representation L D L^T - SIGMA I = L(+) D(+) L(+)^T such that at least one of the eigenvalues of L(+) D(+) L(+)^T is relatively isolated.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=dp), | intent(in) | :: | d(*) | |||
| real(kind=dp), | intent(in) | :: | l(*) | |||
| real(kind=dp), | intent(in) | :: | ld(*) | |||
| integer(kind=ilp), | intent(in) | :: | clstrt | |||
| integer(kind=ilp), | intent(in) | :: | clend | |||
| real(kind=dp), | intent(in) | :: | w(*) | |||
| real(kind=dp), | intent(inout) | :: | wgap(*) | |||
| real(kind=dp), | intent(in) | :: | werr(*) | |||
| real(kind=dp), | intent(in) | :: | spdiam | |||
| real(kind=dp), | intent(in) | :: | clgapl | |||
| real(kind=dp), | intent(in) | :: | clgapr | |||
| real(kind=dp), | intent(in) | :: | pivmin | |||
| real(kind=dp), | intent(out) | :: | sigma | |||
| real(kind=dp), | intent(out) | :: | dplus(*) | |||
| real(kind=dp), | intent(out) | :: | lplus(*) | |||
| real(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
Given the initial representation L D L^T and its cluster of close eigenvalues (in a relative measure), W( CLSTRT ), W( CLSTRT+1 ), ... W( CLEND ), SLARRF: finds a new relatively robust representation L D L^T - SIGMA I = L(+) D(+) L(+)^T such that at least one of the eigenvalues of L(+) D(+) L(+)^T is relatively isolated.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=sp), | intent(in) | :: | d(*) | |||
| real(kind=sp), | intent(in) | :: | l(*) | |||
| real(kind=sp), | intent(in) | :: | ld(*) | |||
| integer(kind=ilp), | intent(in) | :: | clstrt | |||
| integer(kind=ilp), | intent(in) | :: | clend | |||
| real(kind=sp), | intent(in) | :: | w(*) | |||
| real(kind=sp), | intent(inout) | :: | wgap(*) | |||
| real(kind=sp), | intent(in) | :: | werr(*) | |||
| real(kind=sp), | intent(in) | :: | spdiam | |||
| real(kind=sp), | intent(in) | :: | clgapl | |||
| real(kind=sp), | intent(in) | :: | clgapr | |||
| real(kind=sp), | intent(in) | :: | pivmin | |||
| real(kind=sp), | intent(out) | :: | sigma | |||
| real(kind=sp), | intent(out) | :: | dplus(*) | |||
| real(kind=sp), | intent(out) | :: | lplus(*) | |||
| real(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
Given the initial eigenvalue approximations of T, LARRJ: does bisection to refine the eigenvalues of T, W( IFIRST-OFFSET ) through W( ILAST-OFFSET ), to more accuracy. Initial guesses for these eigenvalues are input in W, the corresponding estimate of the error in these guesses in WERR. During bisection, intervals [left, right] are maintained by storing their mid-points and semi-widths in the arrays W and WERR respectively.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=dp), | intent(in) | :: | d(*) | |||
| real(kind=dp), | intent(in) | :: | e2(*) | |||
| integer(kind=ilp), | intent(in) | :: | ifirst | |||
| integer(kind=ilp), | intent(in) | :: | ilast | |||
| real(kind=dp), | intent(in) | :: | rtol | |||
| integer(kind=ilp), | intent(in) | :: | offset | |||
| real(kind=dp), | intent(inout) | :: | w(*) | |||
| real(kind=dp), | intent(inout) | :: | werr(*) | |||
| real(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | iwork(*) | |||
| real(kind=dp), | intent(in) | :: | pivmin | |||
| real(kind=dp), | intent(in) | :: | spdiam | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=sp), | intent(in) | :: | d(*) | |||
| real(kind=sp), | intent(in) | :: | e2(*) | |||
| integer(kind=ilp), | intent(in) | :: | ifirst | |||
| integer(kind=ilp), | intent(in) | :: | ilast | |||
| real(kind=sp), | intent(in) | :: | rtol | |||
| integer(kind=ilp), | intent(in) | :: | offset | |||
| real(kind=sp), | intent(inout) | :: | w(*) | |||
| real(kind=sp), | intent(inout) | :: | werr(*) | |||
| real(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | iwork(*) | |||
| real(kind=sp), | intent(in) | :: | pivmin | |||
| real(kind=sp), | intent(in) | :: | spdiam | |||
| integer(kind=ilp), | intent(out) | :: | info |
Given the initial eigenvalue approximations of T, DLARRJ: does bisection to refine the eigenvalues of T, W( IFIRST-OFFSET ) through W( ILAST-OFFSET ), to more accuracy. Initial guesses for these eigenvalues are input in W, the corresponding estimate of the error in these guesses in WERR. During bisection, intervals [left, right] are maintained by storing their mid-points and semi-widths in the arrays W and WERR respectively.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=dp), | intent(in) | :: | d(*) | |||
| real(kind=dp), | intent(in) | :: | e2(*) | |||
| integer(kind=ilp), | intent(in) | :: | ifirst | |||
| integer(kind=ilp), | intent(in) | :: | ilast | |||
| real(kind=dp), | intent(in) | :: | rtol | |||
| integer(kind=ilp), | intent(in) | :: | offset | |||
| real(kind=dp), | intent(inout) | :: | w(*) | |||
| real(kind=dp), | intent(inout) | :: | werr(*) | |||
| real(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | iwork(*) | |||
| real(kind=dp), | intent(in) | :: | pivmin | |||
| real(kind=dp), | intent(in) | :: | spdiam | |||
| integer(kind=ilp), | intent(out) | :: | info |
Given the initial eigenvalue approximations of T, SLARRJ: does bisection to refine the eigenvalues of T, W( IFIRST-OFFSET ) through W( ILAST-OFFSET ), to more accuracy. Initial guesses for these eigenvalues are input in W, the corresponding estimate of the error in these guesses in WERR. During bisection, intervals [left, right] are maintained by storing their mid-points and semi-widths in the arrays W and WERR respectively.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=sp), | intent(in) | :: | d(*) | |||
| real(kind=sp), | intent(in) | :: | e2(*) | |||
| integer(kind=ilp), | intent(in) | :: | ifirst | |||
| integer(kind=ilp), | intent(in) | :: | ilast | |||
| real(kind=sp), | intent(in) | :: | rtol | |||
| integer(kind=ilp), | intent(in) | :: | offset | |||
| real(kind=sp), | intent(inout) | :: | w(*) | |||
| real(kind=sp), | intent(inout) | :: | werr(*) | |||
| real(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | iwork(*) | |||
| real(kind=sp), | intent(in) | :: | pivmin | |||
| real(kind=sp), | intent(in) | :: | spdiam | |||
| integer(kind=ilp), | intent(out) | :: | info |
LARRK computes one eigenvalue of a symmetric tridiagonal matrix T to suitable accuracy. This is an auxiliary code to be called from DSTEMR. To avoid overflow, the matrix must be scaled so that its largest element is no greater than overflow(1/2) * underflow(1/4) in absolute value, and for greatest accuracy, it should not be much smaller than that. See W. Kahan "Accurate Eigenvalues of a Symmetric Tridiagonal Matrix", Report CS41, Computer Science Dept., Stanford University, July 21, 1966.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | iw | |||
| real(kind=dp), | intent(in) | :: | gl | |||
| real(kind=dp), | intent(in) | :: | gu | |||
| real(kind=dp), | intent(in) | :: | d(*) | |||
| real(kind=dp), | intent(in) | :: | e2(*) | |||
| real(kind=dp), | intent(in) | :: | pivmin | |||
| real(kind=dp), | intent(in) | :: | reltol | |||
| real(kind=dp), | intent(out) | :: | w | |||
| real(kind=dp), | intent(out) | :: | werr | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | iw | |||
| real(kind=sp), | intent(in) | :: | gl | |||
| real(kind=sp), | intent(in) | :: | gu | |||
| real(kind=sp), | intent(in) | :: | d(*) | |||
| real(kind=sp), | intent(in) | :: | e2(*) | |||
| real(kind=sp), | intent(in) | :: | pivmin | |||
| real(kind=sp), | intent(in) | :: | reltol | |||
| real(kind=sp), | intent(out) | :: | w | |||
| real(kind=sp), | intent(out) | :: | werr | |||
| integer(kind=ilp), | intent(out) | :: | info |
DLARRK computes one eigenvalue of a symmetric tridiagonal matrix T to suitable accuracy. This is an auxiliary code to be called from DSTEMR. To avoid overflow, the matrix must be scaled so that its largest element is no greater than overflow(1/2) * underflow(1/4) in absolute value, and for greatest accuracy, it should not be much smaller than that. See W. Kahan "Accurate Eigenvalues of a Symmetric Tridiagonal Matrix", Report CS41, Computer Science Dept., Stanford University, July 21, 1966.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | iw | |||
| real(kind=dp), | intent(in) | :: | gl | |||
| real(kind=dp), | intent(in) | :: | gu | |||
| real(kind=dp), | intent(in) | :: | d(*) | |||
| real(kind=dp), | intent(in) | :: | e2(*) | |||
| real(kind=dp), | intent(in) | :: | pivmin | |||
| real(kind=dp), | intent(in) | :: | reltol | |||
| real(kind=dp), | intent(out) | :: | w | |||
| real(kind=dp), | intent(out) | :: | werr | |||
| integer(kind=ilp), | intent(out) | :: | info |
SLARRK computes one eigenvalue of a symmetric tridiagonal matrix T to suitable accuracy. This is an auxiliary code to be called from SSTEMR. To avoid overflow, the matrix must be scaled so that its largest element is no greater than overflow(1/2) * underflow(1/4) in absolute value, and for greatest accuracy, it should not be much smaller than that. See W. Kahan "Accurate Eigenvalues of a Symmetric Tridiagonal Matrix", Report CS41, Computer Science Dept., Stanford University, July 21, 1966.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | iw | |||
| real(kind=sp), | intent(in) | :: | gl | |||
| real(kind=sp), | intent(in) | :: | gu | |||
| real(kind=sp), | intent(in) | :: | d(*) | |||
| real(kind=sp), | intent(in) | :: | e2(*) | |||
| real(kind=sp), | intent(in) | :: | pivmin | |||
| real(kind=sp), | intent(in) | :: | reltol | |||
| real(kind=sp), | intent(out) | :: | w | |||
| real(kind=sp), | intent(out) | :: | werr | |||
| integer(kind=ilp), | intent(out) | :: | info |
Perform tests to decide whether the symmetric tridiagonal matrix T warrants expensive computations which guarantee high relative accuracy in the eigenvalues.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=dp), | intent(in) | :: | d(*) | |||
| real(kind=dp), | intent(inout) | :: | e(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=sp), | intent(in) | :: | d(*) | |||
| real(kind=sp), | intent(inout) | :: | e(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
Perform tests to decide whether the symmetric tridiagonal matrix T warrants expensive computations which guarantee high relative accuracy in the eigenvalues.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=dp), | intent(in) | :: | d(*) | |||
| real(kind=dp), | intent(inout) | :: | e(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
Perform tests to decide whether the symmetric tridiagonal matrix T warrants expensive computations which guarantee high relative accuracy in the eigenvalues.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=sp), | intent(in) | :: | d(*) | |||
| real(kind=sp), | intent(inout) | :: | e(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
LARRV computes the eigenvectors of the tridiagonal matrix T = L D LT given L, D and APPROXIMATIONS to the eigenvalues of L D LT. The input eigenvalues should have been computed by SLARRE.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=sp), | intent(in) | :: | vl | |||
| real(kind=sp), | intent(in) | :: | vu | |||
| real(kind=sp), | intent(inout) | :: | d(*) | |||
| real(kind=sp), | intent(inout) | :: | l(*) | |||
| real(kind=sp), | intent(in) | :: | pivmin | |||
| integer(kind=ilp), | intent(in) | :: | isplit(*) | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | dol | |||
| integer(kind=ilp), | intent(in) | :: | dou | |||
| real(kind=sp), | intent(in) | :: | minrgp | |||
| real(kind=sp), | intent(inout) | :: | rtol1 | |||
| real(kind=sp), | intent(inout) | :: | rtol2 | |||
| real(kind=sp), | intent(inout) | :: | w(*) | |||
| real(kind=sp), | intent(inout) | :: | werr(*) | |||
| real(kind=sp), | intent(inout) | :: | wgap(*) | |||
| integer(kind=ilp), | intent(in) | :: | iblock(*) | |||
| integer(kind=ilp), | intent(in) | :: | indexw(*) | |||
| real(kind=sp), | intent(in) | :: | gers(*) | |||
| complex(kind=sp), | intent(out) | :: | z(ldz,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldz | |||
| integer(kind=ilp), | intent(out) | :: | isuppz(*) | |||
| real(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | iwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=dp), | intent(in) | :: | vl | |||
| real(kind=dp), | intent(in) | :: | vu | |||
| real(kind=dp), | intent(inout) | :: | d(*) | |||
| real(kind=dp), | intent(inout) | :: | l(*) | |||
| real(kind=dp), | intent(in) | :: | pivmin | |||
| integer(kind=ilp), | intent(in) | :: | isplit(*) | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | dol | |||
| integer(kind=ilp), | intent(in) | :: | dou | |||
| real(kind=dp), | intent(in) | :: | minrgp | |||
| real(kind=dp), | intent(inout) | :: | rtol1 | |||
| real(kind=dp), | intent(inout) | :: | rtol2 | |||
| real(kind=dp), | intent(inout) | :: | w(*) | |||
| real(kind=dp), | intent(inout) | :: | werr(*) | |||
| real(kind=dp), | intent(inout) | :: | wgap(*) | |||
| integer(kind=ilp), | intent(in) | :: | iblock(*) | |||
| integer(kind=ilp), | intent(in) | :: | indexw(*) | |||
| real(kind=dp), | intent(in) | :: | gers(*) | |||
| real(kind=dp), | intent(out) | :: | z(ldz,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldz | |||
| integer(kind=ilp), | intent(out) | :: | isuppz(*) | |||
| real(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | iwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=sp), | intent(in) | :: | vl | |||
| real(kind=sp), | intent(in) | :: | vu | |||
| real(kind=sp), | intent(inout) | :: | d(*) | |||
| real(kind=sp), | intent(inout) | :: | l(*) | |||
| real(kind=sp), | intent(in) | :: | pivmin | |||
| integer(kind=ilp), | intent(in) | :: | isplit(*) | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | dol | |||
| integer(kind=ilp), | intent(in) | :: | dou | |||
| real(kind=sp), | intent(in) | :: | minrgp | |||
| real(kind=sp), | intent(inout) | :: | rtol1 | |||
| real(kind=sp), | intent(inout) | :: | rtol2 | |||
| real(kind=sp), | intent(inout) | :: | w(*) | |||
| real(kind=sp), | intent(inout) | :: | werr(*) | |||
| real(kind=sp), | intent(inout) | :: | wgap(*) | |||
| integer(kind=ilp), | intent(in) | :: | iblock(*) | |||
| integer(kind=ilp), | intent(in) | :: | indexw(*) | |||
| real(kind=sp), | intent(in) | :: | gers(*) | |||
| real(kind=sp), | intent(out) | :: | z(ldz,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldz | |||
| integer(kind=ilp), | intent(out) | :: | isuppz(*) | |||
| real(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | iwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=dp), | intent(in) | :: | vl | |||
| real(kind=dp), | intent(in) | :: | vu | |||
| real(kind=dp), | intent(inout) | :: | d(*) | |||
| real(kind=dp), | intent(inout) | :: | l(*) | |||
| real(kind=dp), | intent(in) | :: | pivmin | |||
| integer(kind=ilp), | intent(in) | :: | isplit(*) | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | dol | |||
| integer(kind=ilp), | intent(in) | :: | dou | |||
| real(kind=dp), | intent(in) | :: | minrgp | |||
| real(kind=dp), | intent(inout) | :: | rtol1 | |||
| real(kind=dp), | intent(inout) | :: | rtol2 | |||
| real(kind=dp), | intent(inout) | :: | w(*) | |||
| real(kind=dp), | intent(inout) | :: | werr(*) | |||
| real(kind=dp), | intent(inout) | :: | wgap(*) | |||
| integer(kind=ilp), | intent(in) | :: | iblock(*) | |||
| integer(kind=ilp), | intent(in) | :: | indexw(*) | |||
| real(kind=dp), | intent(in) | :: | gers(*) | |||
| complex(kind=dp), | intent(out) | :: | z(ldz,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldz | |||
| integer(kind=ilp), | intent(out) | :: | isuppz(*) | |||
| real(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | iwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
CLARRV computes the eigenvectors of the tridiagonal matrix T = L D LT given L, D and APPROXIMATIONS to the eigenvalues of L D LT. The input eigenvalues should have been computed by SLARRE.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=sp), | intent(in) | :: | vl | |||
| real(kind=sp), | intent(in) | :: | vu | |||
| real(kind=sp), | intent(inout) | :: | d(*) | |||
| real(kind=sp), | intent(inout) | :: | l(*) | |||
| real(kind=sp), | intent(in) | :: | pivmin | |||
| integer(kind=ilp), | intent(in) | :: | isplit(*) | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | dol | |||
| integer(kind=ilp), | intent(in) | :: | dou | |||
| real(kind=sp), | intent(in) | :: | minrgp | |||
| real(kind=sp), | intent(inout) | :: | rtol1 | |||
| real(kind=sp), | intent(inout) | :: | rtol2 | |||
| real(kind=sp), | intent(inout) | :: | w(*) | |||
| real(kind=sp), | intent(inout) | :: | werr(*) | |||
| real(kind=sp), | intent(inout) | :: | wgap(*) | |||
| integer(kind=ilp), | intent(in) | :: | iblock(*) | |||
| integer(kind=ilp), | intent(in) | :: | indexw(*) | |||
| real(kind=sp), | intent(in) | :: | gers(*) | |||
| complex(kind=sp), | intent(out) | :: | z(ldz,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldz | |||
| integer(kind=ilp), | intent(out) | :: | isuppz(*) | |||
| real(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | iwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
DLARRV computes the eigenvectors of the tridiagonal matrix T = L D LT given L, D and APPROXIMATIONS to the eigenvalues of L D LT. The input eigenvalues should have been computed by DLARRE.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=dp), | intent(in) | :: | vl | |||
| real(kind=dp), | intent(in) | :: | vu | |||
| real(kind=dp), | intent(inout) | :: | d(*) | |||
| real(kind=dp), | intent(inout) | :: | l(*) | |||
| real(kind=dp), | intent(in) | :: | pivmin | |||
| integer(kind=ilp), | intent(in) | :: | isplit(*) | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | dol | |||
| integer(kind=ilp), | intent(in) | :: | dou | |||
| real(kind=dp), | intent(in) | :: | minrgp | |||
| real(kind=dp), | intent(inout) | :: | rtol1 | |||
| real(kind=dp), | intent(inout) | :: | rtol2 | |||
| real(kind=dp), | intent(inout) | :: | w(*) | |||
| real(kind=dp), | intent(inout) | :: | werr(*) | |||
| real(kind=dp), | intent(inout) | :: | wgap(*) | |||
| integer(kind=ilp), | intent(in) | :: | iblock(*) | |||
| integer(kind=ilp), | intent(in) | :: | indexw(*) | |||
| real(kind=dp), | intent(in) | :: | gers(*) | |||
| real(kind=dp), | intent(out) | :: | z(ldz,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldz | |||
| integer(kind=ilp), | intent(out) | :: | isuppz(*) | |||
| real(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | iwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
SLARRV computes the eigenvectors of the tridiagonal matrix T = L D LT given L, D and APPROXIMATIONS to the eigenvalues of L D LT. The input eigenvalues should have been computed by SLARRE.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=sp), | intent(in) | :: | vl | |||
| real(kind=sp), | intent(in) | :: | vu | |||
| real(kind=sp), | intent(inout) | :: | d(*) | |||
| real(kind=sp), | intent(inout) | :: | l(*) | |||
| real(kind=sp), | intent(in) | :: | pivmin | |||
| integer(kind=ilp), | intent(in) | :: | isplit(*) | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | dol | |||
| integer(kind=ilp), | intent(in) | :: | dou | |||
| real(kind=sp), | intent(in) | :: | minrgp | |||
| real(kind=sp), | intent(inout) | :: | rtol1 | |||
| real(kind=sp), | intent(inout) | :: | rtol2 | |||
| real(kind=sp), | intent(inout) | :: | w(*) | |||
| real(kind=sp), | intent(inout) | :: | werr(*) | |||
| real(kind=sp), | intent(inout) | :: | wgap(*) | |||
| integer(kind=ilp), | intent(in) | :: | iblock(*) | |||
| integer(kind=ilp), | intent(in) | :: | indexw(*) | |||
| real(kind=sp), | intent(in) | :: | gers(*) | |||
| real(kind=sp), | intent(out) | :: | z(ldz,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldz | |||
| integer(kind=ilp), | intent(out) | :: | isuppz(*) | |||
| real(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | iwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
ZLARRV computes the eigenvectors of the tridiagonal matrix T = L D LT given L, D and APPROXIMATIONS to the eigenvalues of L D LT. The input eigenvalues should have been computed by DLARRE.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=dp), | intent(in) | :: | vl | |||
| real(kind=dp), | intent(in) | :: | vu | |||
| real(kind=dp), | intent(inout) | :: | d(*) | |||
| real(kind=dp), | intent(inout) | :: | l(*) | |||
| real(kind=dp), | intent(in) | :: | pivmin | |||
| integer(kind=ilp), | intent(in) | :: | isplit(*) | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | dol | |||
| integer(kind=ilp), | intent(in) | :: | dou | |||
| real(kind=dp), | intent(in) | :: | minrgp | |||
| real(kind=dp), | intent(inout) | :: | rtol1 | |||
| real(kind=dp), | intent(inout) | :: | rtol2 | |||
| real(kind=dp), | intent(inout) | :: | w(*) | |||
| real(kind=dp), | intent(inout) | :: | werr(*) | |||
| real(kind=dp), | intent(inout) | :: | wgap(*) | |||
| integer(kind=ilp), | intent(in) | :: | iblock(*) | |||
| integer(kind=ilp), | intent(in) | :: | indexw(*) | |||
| real(kind=dp), | intent(in) | :: | gers(*) | |||
| complex(kind=dp), | intent(out) | :: | z(ldz,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldz | |||
| integer(kind=ilp), | intent(out) | :: | isuppz(*) | |||
| real(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | iwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
LARTG generates a plane rotation so that [ C S ] . [ F ] = [ R ] [ -conjg(S) C ] [ G ] [ 0 ] where C is real and C2 + |S|2 = 1. The mathematical formulas used for C and S are sgn(x) = { x / |x|, x != 0 { 1, x = 0 R = sgn(F) * sqrt(|F|2 + |G|2) C = |F| / sqrt(|F|2 + |G|2) S = sgn(F) * conjg(G) / sqrt(|F|2 + |G|2) When F and G are real, the formulas simplify to C = F/R and S = G/R, and the returned values of C, S, and R should be identical to those returned by LARTG. The algorithm used to compute these quantities incorporates scaling to avoid overflow or underflow in computing the square root of the sum of squares. This is a faster version of the BLAS1 routine CROTG, except for the following differences: F and G are unchanged on return. If G=0, then C=1 and S=0. If F=0, then C=0 and S is chosen so that R is real. Below, wp=>sp stands for single precision from LA_CONSTANTS module.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| complex(kind=sp), | intent(in) | :: | f | |||
| complex(kind=sp), | intent(in) | :: | g | |||
| real(kind=sp), | intent(out) | :: | c | |||
| complex(kind=sp), | intent(out) | :: | s | |||
| complex(kind=sp), | intent(out) | :: | r |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| real(kind=dp), | intent(in) | :: | f | |||
| real(kind=dp), | intent(in) | :: | g | |||
| real(kind=dp), | intent(out) | :: | c | |||
| real(kind=dp), | intent(out) | :: | s | |||
| real(kind=dp), | intent(out) | :: | r |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| real(kind=sp), | intent(in) | :: | f | |||
| real(kind=sp), | intent(in) | :: | g | |||
| real(kind=sp), | intent(out) | :: | c | |||
| real(kind=sp), | intent(out) | :: | s | |||
| real(kind=sp), | intent(out) | :: | r |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| complex(kind=dp), | intent(in) | :: | f | |||
| complex(kind=dp), | intent(in) | :: | g | |||
| real(kind=dp), | intent(out) | :: | c | |||
| complex(kind=dp), | intent(out) | :: | s | |||
| complex(kind=dp), | intent(out) | :: | r |
CLARTG generates a plane rotation so that [ C S ] . [ F ] = [ R ] [ -conjg(S) C ] [ G ] [ 0 ] where C is real and C2 + |S|2 = 1. The mathematical formulas used for C and S are sgn(x) = { x / |x|, x != 0 { 1, x = 0 R = sgn(F) * sqrt(|F|2 + |G|2) C = |F| / sqrt(|F|2 + |G|2) S = sgn(F) * conjg(G) / sqrt(|F|2 + |G|2) When F and G are real, the formulas simplify to C = F/R and S = G/R, and the returned values of C, S, and R should be identical to those returned by CLARTG. The algorithm used to compute these quantities incorporates scaling to avoid overflow or underflow in computing the square root of the sum of squares. This is a faster version of the BLAS1 routine CROTG, except for the following differences: F and G are unchanged on return. If G=0, then C=1 and S=0. If F=0, then C=0 and S is chosen so that R is real. Below, wp=>sp stands for single precision from LA_CONSTANTS module.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| complex(kind=sp), | intent(in) | :: | f | |||
| complex(kind=sp), | intent(in) | :: | g | |||
| real(kind=sp), | intent(out) | :: | c | |||
| complex(kind=sp), | intent(out) | :: | s | |||
| complex(kind=sp), | intent(out) | :: | r |
DLARTG generates a plane rotation so that [ C S ] . [ F ] = [ R ] [ -S C ] [ G ] [ 0 ] where C2 + S2 = 1. The mathematical formulas used for C and S are R = sign(F) * sqrt(F2 + G2) C = F / R S = G / R Hence C >= 0. The algorithm used to compute these quantities incorporates scaling to avoid overflow or underflow in computing the square root of the sum of squares. This version is discontinuous in R at F = 0 but it returns the same C and S as ZLARTG for complex inputs (F,0) and (G,0). This is a more accurate version of the BLAS1 routine DROTG, with the following other differences: F and G are unchanged on return. If G=0, then C=1 and S=0. If F=0 and (G .ne. 0), then C=0 and S=sign(1,G) without doing any floating point operations (saves work in DBDSQR when there are zeros on the diagonal). If F exceeds G in magnitude, C will be positive. Below, wp=>dp stands for double precision from LA_CONSTANTS module.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| real(kind=dp), | intent(in) | :: | f | |||
| real(kind=dp), | intent(in) | :: | g | |||
| real(kind=dp), | intent(out) | :: | c | |||
| real(kind=dp), | intent(out) | :: | s | |||
| real(kind=dp), | intent(out) | :: | r |
SLARTG generates a plane rotation so that [ C S ] . [ F ] = [ R ] [ -S C ] [ G ] [ 0 ] where C2 + S2 = 1. The mathematical formulas used for C and S are R = sign(F) * sqrt(F2 + G2) C = F / R S = G / R Hence C >= 0. The algorithm used to compute these quantities incorporates scaling to avoid overflow or underflow in computing the square root of the sum of squares. This version is discontinuous in R at F = 0 but it returns the same C and S as SLARTG for complex inputs (F,0) and (G,0). This is a more accurate version of the BLAS1 routine SROTG, with the following other differences: F and G are unchanged on return. If G=0, then C=1 and S=0. If F=0 and (G .ne. 0), then C=0 and S=sign(1,G) without doing any floating point operations (saves work in SBDSQR when there are zeros on the diagonal). If F exceeds G in magnitude, C will be positive. Below, wp=>sp stands for single precision from LA_CONSTANTS module.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| real(kind=sp), | intent(in) | :: | f | |||
| real(kind=sp), | intent(in) | :: | g | |||
| real(kind=sp), | intent(out) | :: | c | |||
| real(kind=sp), | intent(out) | :: | s | |||
| real(kind=sp), | intent(out) | :: | r |
ZLARTG generates a plane rotation so that [ C S ] . [ F ] = [ R ] [ -conjg(S) C ] [ G ] [ 0 ] where C is real and C2 + |S|2 = 1. The mathematical formulas used for C and S are sgn(x) = { x / |x|, x != 0 { 1, x = 0 R = sgn(F) * sqrt(|F|2 + |G|2) C = |F| / sqrt(|F|2 + |G|2) S = sgn(F) * conjg(G) / sqrt(|F|2 + |G|2) When F and G are real, the formulas simplify to C = F/R and S = G/R, and the returned values of C, S, and R should be identical to those returned by DLARTG. The algorithm used to compute these quantities incorporates scaling to avoid overflow or underflow in computing the square root of the sum of squares. This is a faster version of the BLAS1 routine ZROTG, except for the following differences: F and G are unchanged on return. If G=0, then C=1 and S=0. If F=0, then C=0 and S is chosen so that R is real. Below, wp=>dp stands for double precision from LA_CONSTANTS module.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| complex(kind=dp), | intent(in) | :: | f | |||
| complex(kind=dp), | intent(in) | :: | g | |||
| real(kind=dp), | intent(out) | :: | c | |||
| complex(kind=dp), | intent(out) | :: | s | |||
| complex(kind=dp), | intent(out) | :: | r |
LARTGP generates a plane rotation so that [ CS SN ] . [ F ] = [ R ] where CS2 + SN2 = 1. [ -SN CS ] [ G ] [ 0 ] This is a slower, more accurate version of the Level 1 BLAS routine DROTG, with the following other differences: F and G are unchanged on return. If G=0, then CS=(+/-)1 and SN=0. If F=0 and (G .ne. 0), then CS=0 and SN=(+/-)1. The sign is chosen so that R >= 0.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| real(kind=dp), | intent(in) | :: | f | |||
| real(kind=dp), | intent(in) | :: | g | |||
| real(kind=dp), | intent(out) | :: | cs | |||
| real(kind=dp), | intent(out) | :: | sn | |||
| real(kind=dp), | intent(out) | :: | r |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| real(kind=sp), | intent(in) | :: | f | |||
| real(kind=sp), | intent(in) | :: | g | |||
| real(kind=sp), | intent(out) | :: | cs | |||
| real(kind=sp), | intent(out) | :: | sn | |||
| real(kind=sp), | intent(out) | :: | r |
DLARTGP generates a plane rotation so that [ CS SN ] . [ F ] = [ R ] where CS2 + SN2 = 1. [ -SN CS ] [ G ] [ 0 ] This is a slower, more accurate version of the Level 1 BLAS routine DROTG, with the following other differences: F and G are unchanged on return. If G=0, then CS=(+/-)1 and SN=0. If F=0 and (G .ne. 0), then CS=0 and SN=(+/-)1. The sign is chosen so that R >= 0.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| real(kind=dp), | intent(in) | :: | f | |||
| real(kind=dp), | intent(in) | :: | g | |||
| real(kind=dp), | intent(out) | :: | cs | |||
| real(kind=dp), | intent(out) | :: | sn | |||
| real(kind=dp), | intent(out) | :: | r |
SLARTGP generates a plane rotation so that [ CS SN ] . [ F ] = [ R ] where CS2 + SN2 = 1. [ -SN CS ] [ G ] [ 0 ] This is a slower, more accurate version of the Level 1 BLAS routine SROTG, with the following other differences: F and G are unchanged on return. If G=0, then CS=(+/-)1 and SN=0. If F=0 and (G .ne. 0), then CS=0 and SN=(+/-)1. The sign is chosen so that R >= 0.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| real(kind=sp), | intent(in) | :: | f | |||
| real(kind=sp), | intent(in) | :: | g | |||
| real(kind=sp), | intent(out) | :: | cs | |||
| real(kind=sp), | intent(out) | :: | sn | |||
| real(kind=sp), | intent(out) | :: | r |
LARTGS generates a plane rotation designed to introduce a bulge in Golub-Reinsch-style implicit QR iteration for the bidiagonal SVD problem. X and Y are the top-row entries, and SIGMA is the shift. The computed CS and SN define a plane rotation satisfying [ CS SN ] . [ X^2 - SIGMA ] = [ R ], [ -SN CS ] [ X * Y ] [ 0 ] with R nonnegative. If X^2 - SIGMA and X * Y are 0, then the rotation is by PI/2.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| real(kind=dp), | intent(in) | :: | x | |||
| real(kind=dp), | intent(in) | :: | y | |||
| real(kind=dp), | intent(in) | :: | sigma | |||
| real(kind=dp), | intent(out) | :: | cs | |||
| real(kind=dp), | intent(out) | :: | sn |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| real(kind=sp), | intent(in) | :: | x | |||
| real(kind=sp), | intent(in) | :: | y | |||
| real(kind=sp), | intent(in) | :: | sigma | |||
| real(kind=sp), | intent(out) | :: | cs | |||
| real(kind=sp), | intent(out) | :: | sn |
DLARTGS generates a plane rotation designed to introduce a bulge in Golub-Reinsch-style implicit QR iteration for the bidiagonal SVD problem. X and Y are the top-row entries, and SIGMA is the shift. The computed CS and SN define a plane rotation satisfying [ CS SN ] . [ X^2 - SIGMA ] = [ R ], [ -SN CS ] [ X * Y ] [ 0 ] with R nonnegative. If X^2 - SIGMA and X * Y are 0, then the rotation is by PI/2.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| real(kind=dp), | intent(in) | :: | x | |||
| real(kind=dp), | intent(in) | :: | y | |||
| real(kind=dp), | intent(in) | :: | sigma | |||
| real(kind=dp), | intent(out) | :: | cs | |||
| real(kind=dp), | intent(out) | :: | sn |
SLARTGS generates a plane rotation designed to introduce a bulge in Golub-Reinsch-style implicit QR iteration for the bidiagonal SVD problem. X and Y are the top-row entries, and SIGMA is the shift. The computed CS and SN define a plane rotation satisfying [ CS SN ] . [ X^2 - SIGMA ] = [ R ], [ -SN CS ] [ X * Y ] [ 0 ] with R nonnegative. If X^2 - SIGMA and X * Y are 0, then the rotation is by PI/2.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| real(kind=sp), | intent(in) | :: | x | |||
| real(kind=sp), | intent(in) | :: | y | |||
| real(kind=sp), | intent(in) | :: | sigma | |||
| real(kind=sp), | intent(out) | :: | cs | |||
| real(kind=sp), | intent(out) | :: | sn |
LARTV applies a vector of complex plane rotations with real cosines to elements of the complex vectors x and y. For i = 1,2,...,n ( x(i) ) := ( c(i) s(i) ) ( x(i) ) ( y(i) ) ( -conjg(s(i)) c(i) ) ( y(i) )
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=sp), | intent(inout) | :: | x(*) | |||
| integer(kind=ilp), | intent(in) | :: | incx | |||
| complex(kind=sp), | intent(inout) | :: | y(*) | |||
| integer(kind=ilp), | intent(in) | :: | incy | |||
| real(kind=sp), | intent(in) | :: | c(*) | |||
| complex(kind=sp), | intent(in) | :: | s(*) | |||
| integer(kind=ilp), | intent(in) | :: | incc |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=dp), | intent(inout) | :: | x(*) | |||
| integer(kind=ilp), | intent(in) | :: | incx | |||
| real(kind=dp), | intent(inout) | :: | y(*) | |||
| integer(kind=ilp), | intent(in) | :: | incy | |||
| real(kind=dp), | intent(in) | :: | c(*) | |||
| real(kind=dp), | intent(in) | :: | s(*) | |||
| integer(kind=ilp), | intent(in) | :: | incc |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=sp), | intent(inout) | :: | x(*) | |||
| integer(kind=ilp), | intent(in) | :: | incx | |||
| real(kind=sp), | intent(inout) | :: | y(*) | |||
| integer(kind=ilp), | intent(in) | :: | incy | |||
| real(kind=sp), | intent(in) | :: | c(*) | |||
| real(kind=sp), | intent(in) | :: | s(*) | |||
| integer(kind=ilp), | intent(in) | :: | incc |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=dp), | intent(inout) | :: | x(*) | |||
| integer(kind=ilp), | intent(in) | :: | incx | |||
| complex(kind=dp), | intent(inout) | :: | y(*) | |||
| integer(kind=ilp), | intent(in) | :: | incy | |||
| real(kind=dp), | intent(in) | :: | c(*) | |||
| complex(kind=dp), | intent(in) | :: | s(*) | |||
| integer(kind=ilp), | intent(in) | :: | incc |
CLARTV applies a vector of complex plane rotations with real cosines to elements of the complex vectors x and y. For i = 1,2,...,n ( x(i) ) := ( c(i) s(i) ) ( x(i) ) ( y(i) ) ( -conjg(s(i)) c(i) ) ( y(i) )
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=sp), | intent(inout) | :: | x(*) | |||
| integer(kind=ilp), | intent(in) | :: | incx | |||
| complex(kind=sp), | intent(inout) | :: | y(*) | |||
| integer(kind=ilp), | intent(in) | :: | incy | |||
| real(kind=sp), | intent(in) | :: | c(*) | |||
| complex(kind=sp), | intent(in) | :: | s(*) | |||
| integer(kind=ilp), | intent(in) | :: | incc |
DLARTV applies a vector of real plane rotations to elements of the real vectors x and y. For i = 1,2,...,n ( x(i) ) := ( c(i) s(i) ) ( x(i) ) ( y(i) ) ( -s(i) c(i) ) ( y(i) )
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=dp), | intent(inout) | :: | x(*) | |||
| integer(kind=ilp), | intent(in) | :: | incx | |||
| real(kind=dp), | intent(inout) | :: | y(*) | |||
| integer(kind=ilp), | intent(in) | :: | incy | |||
| real(kind=dp), | intent(in) | :: | c(*) | |||
| real(kind=dp), | intent(in) | :: | s(*) | |||
| integer(kind=ilp), | intent(in) | :: | incc |
SLARTV applies a vector of real plane rotations to elements of the real vectors x and y. For i = 1,2,...,n ( x(i) ) := ( c(i) s(i) ) ( x(i) ) ( y(i) ) ( -s(i) c(i) ) ( y(i) )
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=sp), | intent(inout) | :: | x(*) | |||
| integer(kind=ilp), | intent(in) | :: | incx | |||
| real(kind=sp), | intent(inout) | :: | y(*) | |||
| integer(kind=ilp), | intent(in) | :: | incy | |||
| real(kind=sp), | intent(in) | :: | c(*) | |||
| real(kind=sp), | intent(in) | :: | s(*) | |||
| integer(kind=ilp), | intent(in) | :: | incc |
ZLARTV applies a vector of complex plane rotations with real cosines to elements of the complex vectors x and y. For i = 1,2,...,n ( x(i) ) := ( c(i) s(i) ) ( x(i) ) ( y(i) ) ( -conjg(s(i)) c(i) ) ( y(i) )
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=dp), | intent(inout) | :: | x(*) | |||
| integer(kind=ilp), | intent(in) | :: | incx | |||
| complex(kind=dp), | intent(inout) | :: | y(*) | |||
| integer(kind=ilp), | intent(in) | :: | incy | |||
| real(kind=dp), | intent(in) | :: | c(*) | |||
| complex(kind=dp), | intent(in) | :: | s(*) | |||
| integer(kind=ilp), | intent(in) | :: | incc |
LARUV returns a vector of n random real numbers from a uniform (0,1) distribution (n <= 128). This is an auxiliary routine called by DLARNV and ZLARNV.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(inout) | :: | iseed(4) | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=dp), | intent(out) | :: | x(n) |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(inout) | :: | iseed(4) | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=sp), | intent(out) | :: | x(n) |
DLARUV returns a vector of n random real numbers from a uniform (0,1) distribution (n <= 128). This is an auxiliary routine called by DLARNV and ZLARNV.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(inout) | :: | iseed(4) | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=dp), | intent(out) | :: | x(n) |
SLARUV returns a vector of n random real numbers from a uniform (0,1) distribution (n <= 128). This is an auxiliary routine called by SLARNV and CLARNV.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(inout) | :: | iseed(4) | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=sp), | intent(out) | :: | x(n) |
LARZ applies a complex elementary reflector H to a complex M-by-N matrix C, from either the left or the right. H is represented in the form H = I - tau * v * vH where tau is a complex scalar and v is a complex vector. If tau = 0, then H is taken to be the unit matrix. To apply HH (the conjugate transpose of H), supply conjg(tau) instead tau. H is a product of k elementary reflectors as returned by CTZRZF.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | side | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | l | |||
| complex(kind=sp), | intent(in) | :: | v(*) | |||
| integer(kind=ilp), | intent(in) | :: | incv | |||
| complex(kind=sp), | intent(in) | :: | tau | |||
| complex(kind=sp), | intent(inout) | :: | c(ldc,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldc | |||
| complex(kind=sp), | intent(out) | :: | work(*) |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | side | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | l | |||
| real(kind=dp), | intent(in) | :: | v(*) | |||
| integer(kind=ilp), | intent(in) | :: | incv | |||
| real(kind=dp), | intent(in) | :: | tau | |||
| real(kind=dp), | intent(inout) | :: | c(ldc,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldc | |||
| real(kind=dp), | intent(out) | :: | work(*) |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | side | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | l | |||
| real(kind=sp), | intent(in) | :: | v(*) | |||
| integer(kind=ilp), | intent(in) | :: | incv | |||
| real(kind=sp), | intent(in) | :: | tau | |||
| real(kind=sp), | intent(inout) | :: | c(ldc,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldc | |||
| real(kind=sp), | intent(out) | :: | work(*) |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | side | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | l | |||
| complex(kind=dp), | intent(in) | :: | v(*) | |||
| integer(kind=ilp), | intent(in) | :: | incv | |||
| complex(kind=dp), | intent(in) | :: | tau | |||
| complex(kind=dp), | intent(inout) | :: | c(ldc,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldc | |||
| complex(kind=dp), | intent(out) | :: | work(*) |
CLARZ applies a complex elementary reflector H to a complex M-by-N matrix C, from either the left or the right. H is represented in the form H = I - tau * v * vH where tau is a complex scalar and v is a complex vector. If tau = 0, then H is taken to be the unit matrix. To apply HH (the conjugate transpose of H), supply conjg(tau) instead tau. H is a product of k elementary reflectors as returned by CTZRZF.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | side | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | l | |||
| complex(kind=sp), | intent(in) | :: | v(*) | |||
| integer(kind=ilp), | intent(in) | :: | incv | |||
| complex(kind=sp), | intent(in) | :: | tau | |||
| complex(kind=sp), | intent(inout) | :: | c(ldc,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldc | |||
| complex(kind=sp), | intent(out) | :: | work(*) |
DLARZ applies a real elementary reflector H to a real M-by-N matrix C, from either the left or the right. H is represented in the form H = I - tau * v * v**T where tau is a real scalar and v is a real vector. If tau = 0, then H is taken to be the unit matrix. H is a product of k elementary reflectors as returned by DTZRZF.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | side | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | l | |||
| real(kind=dp), | intent(in) | :: | v(*) | |||
| integer(kind=ilp), | intent(in) | :: | incv | |||
| real(kind=dp), | intent(in) | :: | tau | |||
| real(kind=dp), | intent(inout) | :: | c(ldc,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldc | |||
| real(kind=dp), | intent(out) | :: | work(*) |
SLARZ applies a real elementary reflector H to a real M-by-N matrix C, from either the left or the right. H is represented in the form H = I - tau * v * v**T where tau is a real scalar and v is a real vector. If tau = 0, then H is taken to be the unit matrix. H is a product of k elementary reflectors as returned by STZRZF.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | side | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | l | |||
| real(kind=sp), | intent(in) | :: | v(*) | |||
| integer(kind=ilp), | intent(in) | :: | incv | |||
| real(kind=sp), | intent(in) | :: | tau | |||
| real(kind=sp), | intent(inout) | :: | c(ldc,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldc | |||
| real(kind=sp), | intent(out) | :: | work(*) |
ZLARZ applies a complex elementary reflector H to a complex M-by-N matrix C, from either the left or the right. H is represented in the form H = I - tau * v * vH where tau is a complex scalar and v is a complex vector. If tau = 0, then H is taken to be the unit matrix. To apply HH (the conjugate transpose of H), supply conjg(tau) instead tau. H is a product of k elementary reflectors as returned by ZTZRZF.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | side | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | l | |||
| complex(kind=dp), | intent(in) | :: | v(*) | |||
| integer(kind=ilp), | intent(in) | :: | incv | |||
| complex(kind=dp), | intent(in) | :: | tau | |||
| complex(kind=dp), | intent(inout) | :: | c(ldc,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldc | |||
| complex(kind=dp), | intent(out) | :: | work(*) |
LARZB applies a complex block reflector H or its transpose H**H to a complex distributed M-by-N C from the left or the right. Currently, only STOREV = 'R' and DIRECT = 'B' are supported.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | side | |||
| character, | intent(in) | :: | trans | |||
| character, | intent(in) | :: | direct | |||
| character, | intent(in) | :: | storev | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | k | |||
| integer(kind=ilp), | intent(in) | :: | l | |||
| complex(kind=sp), | intent(inout) | :: | v(ldv,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldv | |||
| complex(kind=sp), | intent(inout) | :: | t(ldt,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldt | |||
| complex(kind=sp), | intent(inout) | :: | c(ldc,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldc | |||
| complex(kind=sp), | intent(out) | :: | work(ldwork,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldwork |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | side | |||
| character, | intent(in) | :: | trans | |||
| character, | intent(in) | :: | direct | |||
| character, | intent(in) | :: | storev | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | k | |||
| integer(kind=ilp), | intent(in) | :: | l | |||
| real(kind=dp), | intent(inout) | :: | v(ldv,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldv | |||
| real(kind=dp), | intent(inout) | :: | t(ldt,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldt | |||
| real(kind=dp), | intent(inout) | :: | c(ldc,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldc | |||
| real(kind=dp), | intent(out) | :: | work(ldwork,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldwork |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | side | |||
| character, | intent(in) | :: | trans | |||
| character, | intent(in) | :: | direct | |||
| character, | intent(in) | :: | storev | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | k | |||
| integer(kind=ilp), | intent(in) | :: | l | |||
| real(kind=sp), | intent(inout) | :: | v(ldv,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldv | |||
| real(kind=sp), | intent(inout) | :: | t(ldt,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldt | |||
| real(kind=sp), | intent(inout) | :: | c(ldc,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldc | |||
| real(kind=sp), | intent(out) | :: | work(ldwork,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldwork |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | side | |||
| character, | intent(in) | :: | trans | |||
| character, | intent(in) | :: | direct | |||
| character, | intent(in) | :: | storev | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | k | |||
| integer(kind=ilp), | intent(in) | :: | l | |||
| complex(kind=dp), | intent(inout) | :: | v(ldv,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldv | |||
| complex(kind=dp), | intent(inout) | :: | t(ldt,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldt | |||
| complex(kind=dp), | intent(inout) | :: | c(ldc,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldc | |||
| complex(kind=dp), | intent(out) | :: | work(ldwork,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldwork |
CLARZB applies a complex block reflector H or its transpose H**H to a complex distributed M-by-N C from the left or the right. Currently, only STOREV = 'R' and DIRECT = 'B' are supported.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | side | |||
| character, | intent(in) | :: | trans | |||
| character, | intent(in) | :: | direct | |||
| character, | intent(in) | :: | storev | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | k | |||
| integer(kind=ilp), | intent(in) | :: | l | |||
| complex(kind=sp), | intent(inout) | :: | v(ldv,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldv | |||
| complex(kind=sp), | intent(inout) | :: | t(ldt,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldt | |||
| complex(kind=sp), | intent(inout) | :: | c(ldc,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldc | |||
| complex(kind=sp), | intent(out) | :: | work(ldwork,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldwork |
DLARZB applies a real block reflector H or its transpose H**T to a real distributed M-by-N C from the left or the right. Currently, only STOREV = 'R' and DIRECT = 'B' are supported.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | side | |||
| character, | intent(in) | :: | trans | |||
| character, | intent(in) | :: | direct | |||
| character, | intent(in) | :: | storev | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | k | |||
| integer(kind=ilp), | intent(in) | :: | l | |||
| real(kind=dp), | intent(inout) | :: | v(ldv,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldv | |||
| real(kind=dp), | intent(inout) | :: | t(ldt,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldt | |||
| real(kind=dp), | intent(inout) | :: | c(ldc,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldc | |||
| real(kind=dp), | intent(out) | :: | work(ldwork,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldwork |
SLARZB applies a real block reflector H or its transpose H**T to a real distributed M-by-N C from the left or the right. Currently, only STOREV = 'R' and DIRECT = 'B' are supported.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | side | |||
| character, | intent(in) | :: | trans | |||
| character, | intent(in) | :: | direct | |||
| character, | intent(in) | :: | storev | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | k | |||
| integer(kind=ilp), | intent(in) | :: | l | |||
| real(kind=sp), | intent(inout) | :: | v(ldv,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldv | |||
| real(kind=sp), | intent(inout) | :: | t(ldt,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldt | |||
| real(kind=sp), | intent(inout) | :: | c(ldc,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldc | |||
| real(kind=sp), | intent(out) | :: | work(ldwork,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldwork |
ZLARZB applies a complex block reflector H or its transpose H**H to a complex distributed M-by-N C from the left or the right. Currently, only STOREV = 'R' and DIRECT = 'B' are supported.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | side | |||
| character, | intent(in) | :: | trans | |||
| character, | intent(in) | :: | direct | |||
| character, | intent(in) | :: | storev | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | k | |||
| integer(kind=ilp), | intent(in) | :: | l | |||
| complex(kind=dp), | intent(inout) | :: | v(ldv,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldv | |||
| complex(kind=dp), | intent(inout) | :: | t(ldt,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldt | |||
| complex(kind=dp), | intent(inout) | :: | c(ldc,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldc | |||
| complex(kind=dp), | intent(out) | :: | work(ldwork,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldwork |
LARZT forms the triangular factor T of a complex block reflector H of order > n, which is defined as a product of k elementary reflectors. If DIRECT = 'F', H = H(1) H(2) . . . H(k) and T is upper triangular; If DIRECT = 'B', H = H(k) . . . H(2) H(1) and T is lower triangular. If STOREV = 'C', the vector which defines the elementary reflector H(i) is stored in the i-th column of the array V, and H = I - V * T * VH If STOREV = 'R', the vector which defines the elementary reflector H(i) is stored in the i-th row of the array V, and H = I - VH * T * V Currently, only STOREV = 'R' and DIRECT = 'B' are supported.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | direct | |||
| character, | intent(in) | :: | storev | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | k | |||
| complex(kind=sp), | intent(inout) | :: | v(ldv,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldv | |||
| complex(kind=sp), | intent(in) | :: | tau(*) | |||
| complex(kind=sp), | intent(out) | :: | t(ldt,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldt |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | direct | |||
| character, | intent(in) | :: | storev | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | k | |||
| real(kind=dp), | intent(inout) | :: | v(ldv,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldv | |||
| real(kind=dp), | intent(in) | :: | tau(*) | |||
| real(kind=dp), | intent(out) | :: | t(ldt,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldt |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | direct | |||
| character, | intent(in) | :: | storev | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | k | |||
| real(kind=sp), | intent(inout) | :: | v(ldv,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldv | |||
| real(kind=sp), | intent(in) | :: | tau(*) | |||
| real(kind=sp), | intent(out) | :: | t(ldt,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldt |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | direct | |||
| character, | intent(in) | :: | storev | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | k | |||
| complex(kind=dp), | intent(inout) | :: | v(ldv,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldv | |||
| complex(kind=dp), | intent(in) | :: | tau(*) | |||
| complex(kind=dp), | intent(out) | :: | t(ldt,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldt |
CLARZT forms the triangular factor T of a complex block reflector H of order > n, which is defined as a product of k elementary reflectors. If DIRECT = 'F', H = H(1) H(2) . . . H(k) and T is upper triangular; If DIRECT = 'B', H = H(k) . . . H(2) H(1) and T is lower triangular. If STOREV = 'C', the vector which defines the elementary reflector H(i) is stored in the i-th column of the array V, and H = I - V * T * VH If STOREV = 'R', the vector which defines the elementary reflector H(i) is stored in the i-th row of the array V, and H = I - VH * T * V Currently, only STOREV = 'R' and DIRECT = 'B' are supported.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | direct | |||
| character, | intent(in) | :: | storev | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | k | |||
| complex(kind=sp), | intent(inout) | :: | v(ldv,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldv | |||
| complex(kind=sp), | intent(in) | :: | tau(*) | |||
| complex(kind=sp), | intent(out) | :: | t(ldt,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldt |
DLARZT forms the triangular factor T of a real block reflector H of order > n, which is defined as a product of k elementary reflectors. If DIRECT = 'F', H = H(1) H(2) . . . H(k) and T is upper triangular; If DIRECT = 'B', H = H(k) . . . H(2) H(1) and T is lower triangular. If STOREV = 'C', the vector which defines the elementary reflector H(i) is stored in the i-th column of the array V, and H = I - V * T * VT If STOREV = 'R', the vector which defines the elementary reflector H(i) is stored in the i-th row of the array V, and H = I - VT * T * V Currently, only STOREV = 'R' and DIRECT = 'B' are supported.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | direct | |||
| character, | intent(in) | :: | storev | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | k | |||
| real(kind=dp), | intent(inout) | :: | v(ldv,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldv | |||
| real(kind=dp), | intent(in) | :: | tau(*) | |||
| real(kind=dp), | intent(out) | :: | t(ldt,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldt |
SLARZT forms the triangular factor T of a real block reflector H of order > n, which is defined as a product of k elementary reflectors. If DIRECT = 'F', H = H(1) H(2) . . . H(k) and T is upper triangular; If DIRECT = 'B', H = H(k) . . . H(2) H(1) and T is lower triangular. If STOREV = 'C', the vector which defines the elementary reflector H(i) is stored in the i-th column of the array V, and H = I - V * T * VT If STOREV = 'R', the vector which defines the elementary reflector H(i) is stored in the i-th row of the array V, and H = I - VT * T * V Currently, only STOREV = 'R' and DIRECT = 'B' are supported.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | direct | |||
| character, | intent(in) | :: | storev | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | k | |||
| real(kind=sp), | intent(inout) | :: | v(ldv,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldv | |||
| real(kind=sp), | intent(in) | :: | tau(*) | |||
| real(kind=sp), | intent(out) | :: | t(ldt,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldt |
ZLARZT forms the triangular factor T of a complex block reflector H of order > n, which is defined as a product of k elementary reflectors. If DIRECT = 'F', H = H(1) H(2) . . . H(k) and T is upper triangular; If DIRECT = 'B', H = H(k) . . . H(2) H(1) and T is lower triangular. If STOREV = 'C', the vector which defines the elementary reflector H(i) is stored in the i-th column of the array V, and H = I - V * T * VH If STOREV = 'R', the vector which defines the elementary reflector H(i) is stored in the i-th row of the array V, and H = I - VH * T * V Currently, only STOREV = 'R' and DIRECT = 'B' are supported.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | direct | |||
| character, | intent(in) | :: | storev | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | k | |||
| complex(kind=dp), | intent(inout) | :: | v(ldv,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldv | |||
| complex(kind=dp), | intent(in) | :: | tau(*) | |||
| complex(kind=dp), | intent(out) | :: | t(ldt,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldt |
LASCL multiplies the M by N complex matrix A by the real scalar CTO/CFROM. This is done without over/underflow as long as the final result CTO*A(I,J)/CFROM does not over/underflow. TYPE specifies that A may be full, upper triangular, lower triangular, upper Hessenberg, or banded.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | type | |||
| integer(kind=ilp), | intent(in) | :: | kl | |||
| integer(kind=ilp), | intent(in) | :: | ku | |||
| real(kind=sp), | intent(in) | :: | cfrom | |||
| real(kind=sp), | intent(in) | :: | cto | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | type | |||
| integer(kind=ilp), | intent(in) | :: | kl | |||
| integer(kind=ilp), | intent(in) | :: | ku | |||
| real(kind=dp), | intent(in) | :: | cfrom | |||
| real(kind=dp), | intent(in) | :: | cto | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | type | |||
| integer(kind=ilp), | intent(in) | :: | kl | |||
| integer(kind=ilp), | intent(in) | :: | ku | |||
| real(kind=sp), | intent(in) | :: | cfrom | |||
| real(kind=sp), | intent(in) | :: | cto | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | type | |||
| integer(kind=ilp), | intent(in) | :: | kl | |||
| integer(kind=ilp), | intent(in) | :: | ku | |||
| real(kind=dp), | intent(in) | :: | cfrom | |||
| real(kind=dp), | intent(in) | :: | cto | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| integer(kind=ilp), | intent(out) | :: | info |
CLASCL multiplies the M by N complex matrix A by the real scalar CTO/CFROM. This is done without over/underflow as long as the final result CTO*A(I,J)/CFROM does not over/underflow. TYPE specifies that A may be full, upper triangular, lower triangular, upper Hessenberg, or banded.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | type | |||
| integer(kind=ilp), | intent(in) | :: | kl | |||
| integer(kind=ilp), | intent(in) | :: | ku | |||
| real(kind=sp), | intent(in) | :: | cfrom | |||
| real(kind=sp), | intent(in) | :: | cto | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| integer(kind=ilp), | intent(out) | :: | info |
DLASCL multiplies the M by N real matrix A by the real scalar CTO/CFROM. This is done without over/underflow as long as the final result CTO*A(I,J)/CFROM does not over/underflow. TYPE specifies that A may be full, upper triangular, lower triangular, upper Hessenberg, or banded.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | type | |||
| integer(kind=ilp), | intent(in) | :: | kl | |||
| integer(kind=ilp), | intent(in) | :: | ku | |||
| real(kind=dp), | intent(in) | :: | cfrom | |||
| real(kind=dp), | intent(in) | :: | cto | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| integer(kind=ilp), | intent(out) | :: | info |
SLASCL multiplies the M by N real matrix A by the real scalar CTO/CFROM. This is done without over/underflow as long as the final result CTO*A(I,J)/CFROM does not over/underflow. TYPE specifies that A may be full, upper triangular, lower triangular, upper Hessenberg, or banded.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | type | |||
| integer(kind=ilp), | intent(in) | :: | kl | |||
| integer(kind=ilp), | intent(in) | :: | ku | |||
| real(kind=sp), | intent(in) | :: | cfrom | |||
| real(kind=sp), | intent(in) | :: | cto | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| integer(kind=ilp), | intent(out) | :: | info |
ZLASCL multiplies the M by N complex matrix A by the real scalar CTO/CFROM. This is done without over/underflow as long as the final result CTO*A(I,J)/CFROM does not over/underflow. TYPE specifies that A may be full, upper triangular, lower triangular, upper Hessenberg, or banded.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | type | |||
| integer(kind=ilp), | intent(in) | :: | kl | |||
| integer(kind=ilp), | intent(in) | :: | ku | |||
| real(kind=dp), | intent(in) | :: | cfrom | |||
| real(kind=dp), | intent(in) | :: | cto | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| integer(kind=ilp), | intent(out) | :: | info |
Using a divide and conquer approach, LASD0: computes the singular value decomposition (SVD) of a real upper bidiagonal N-by-M matrix B with diagonal D and offdiagonal E, where M = N + SQRE. The algorithm computes orthogonal matrices U and VT such that B = U * S * VT. The singular values S are overwritten on D. A related subroutine, DLASDA, computes only the singular values, and optionally, the singular vectors in compact form.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | sqre | |||
| real(kind=dp), | intent(inout) | :: | d(*) | |||
| real(kind=dp), | intent(inout) | :: | e(*) | |||
| real(kind=dp), | intent(out) | :: | u(ldu,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldu | |||
| real(kind=dp), | intent(out) | :: | vt(ldvt,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldvt | |||
| integer(kind=ilp), | intent(in) | :: | smlsiz | |||
| integer(kind=ilp), | intent(out) | :: | iwork(*) | |||
| real(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | sqre | |||
| real(kind=sp), | intent(inout) | :: | d(*) | |||
| real(kind=sp), | intent(inout) | :: | e(*) | |||
| real(kind=sp), | intent(out) | :: | u(ldu,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldu | |||
| real(kind=sp), | intent(out) | :: | vt(ldvt,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldvt | |||
| integer(kind=ilp), | intent(in) | :: | smlsiz | |||
| integer(kind=ilp), | intent(out) | :: | iwork(*) | |||
| real(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
Using a divide and conquer approach, DLASD0: computes the singular value decomposition (SVD) of a real upper bidiagonal N-by-M matrix B with diagonal D and offdiagonal E, where M = N + SQRE. The algorithm computes orthogonal matrices U and VT such that B = U * S * VT. The singular values S are overwritten on D. A related subroutine, DLASDA, computes only the singular values, and optionally, the singular vectors in compact form.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | sqre | |||
| real(kind=dp), | intent(inout) | :: | d(*) | |||
| real(kind=dp), | intent(inout) | :: | e(*) | |||
| real(kind=dp), | intent(out) | :: | u(ldu,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldu | |||
| real(kind=dp), | intent(out) | :: | vt(ldvt,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldvt | |||
| integer(kind=ilp), | intent(in) | :: | smlsiz | |||
| integer(kind=ilp), | intent(out) | :: | iwork(*) | |||
| real(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
Using a divide and conquer approach, SLASD0: computes the singular value decomposition (SVD) of a real upper bidiagonal N-by-M matrix B with diagonal D and offdiagonal E, where M = N + SQRE. The algorithm computes orthogonal matrices U and VT such that B = U * S * VT. The singular values S are overwritten on D. A related subroutine, SLASDA, computes only the singular values, and optionally, the singular vectors in compact form.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | sqre | |||
| real(kind=sp), | intent(inout) | :: | d(*) | |||
| real(kind=sp), | intent(inout) | :: | e(*) | |||
| real(kind=sp), | intent(out) | :: | u(ldu,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldu | |||
| real(kind=sp), | intent(out) | :: | vt(ldvt,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldvt | |||
| integer(kind=ilp), | intent(in) | :: | smlsiz | |||
| integer(kind=ilp), | intent(out) | :: | iwork(*) | |||
| real(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
LASD1 computes the SVD of an upper bidiagonal N-by-M matrix B, where N = NL + NR + 1 and M = N + SQRE. LASD1 is called from DLASD0. A related subroutine DLASD7 handles the case in which the singular values (and the singular vectors in factored form) are desired. LASD1 computes the SVD as follows: ( D1(in) 0 0 0 ) B = U(in) * ( Z1T a Z2T b ) * VT(in) ( 0 0 D2(in) 0 ) = U(out) * ( D(out) 0) * VT(out) where ZT = (Z1T a Z2T b) = uT VT**T, and u is a vector of dimension M with ALPHA and BETA in the NL+1 and NL+2 th entries and zeros elsewhere; and the entry b is empty if SQRE = 0. The left singular vectors of the original matrix are stored in U, and the transpose of the right singular vectors are stored in VT, and the singular values are in D. The algorithm consists of three stages: The first stage consists of deflating the size of the problem when there are multiple singular values or when there are zeros in the Z vector. For each such occurrence the dimension of the secular equation problem is reduced by one. This stage is performed by the routine DLASD2. The second stage consists of calculating the updated singular values. This is done by finding the square roots of the roots of the secular equation via the routine DLASD4 (as called by DLASD3). This routine also calculates the singular vectors of the current problem. The final stage consists of computing the updated singular vectors directly using the updated singular values. The singular vectors for the current problem are multiplied with the singular vectors from the overall problem.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | nl | |||
| integer(kind=ilp), | intent(in) | :: | nr | |||
| integer(kind=ilp), | intent(in) | :: | sqre | |||
| real(kind=dp), | intent(inout) | :: | d(*) | |||
| real(kind=dp), | intent(inout) | :: | alpha | |||
| real(kind=dp), | intent(inout) | :: | beta | |||
| real(kind=dp), | intent(inout) | :: | u(ldu,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldu | |||
| real(kind=dp), | intent(inout) | :: | vt(ldvt,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldvt | |||
| integer(kind=ilp), | intent(inout) | :: | idxq(*) | |||
| integer(kind=ilp), | intent(out) | :: | iwork(*) | |||
| real(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | nl | |||
| integer(kind=ilp), | intent(in) | :: | nr | |||
| integer(kind=ilp), | intent(in) | :: | sqre | |||
| real(kind=sp), | intent(inout) | :: | d(*) | |||
| real(kind=sp), | intent(inout) | :: | alpha | |||
| real(kind=sp), | intent(inout) | :: | beta | |||
| real(kind=sp), | intent(inout) | :: | u(ldu,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldu | |||
| real(kind=sp), | intent(inout) | :: | vt(ldvt,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldvt | |||
| integer(kind=ilp), | intent(inout) | :: | idxq(*) | |||
| integer(kind=ilp), | intent(out) | :: | iwork(*) | |||
| real(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
DLASD1 computes the SVD of an upper bidiagonal N-by-M matrix B, where N = NL + NR + 1 and M = N + SQRE. DLASD1 is called from DLASD0. A related subroutine DLASD7 handles the case in which the singular values (and the singular vectors in factored form) are desired. DLASD1 computes the SVD as follows: ( D1(in) 0 0 0 ) B = U(in) * ( Z1T a Z2T b ) * VT(in) ( 0 0 D2(in) 0 ) = U(out) * ( D(out) 0) * VT(out) where ZT = (Z1T a Z2T b) = uT VT**T, and u is a vector of dimension M with ALPHA and BETA in the NL+1 and NL+2 th entries and zeros elsewhere; and the entry b is empty if SQRE = 0. The left singular vectors of the original matrix are stored in U, and the transpose of the right singular vectors are stored in VT, and the singular values are in D. The algorithm consists of three stages: The first stage consists of deflating the size of the problem when there are multiple singular values or when there are zeros in the Z vector. For each such occurrence the dimension of the secular equation problem is reduced by one. This stage is performed by the routine DLASD2. The second stage consists of calculating the updated singular values. This is done by finding the square roots of the roots of the secular equation via the routine DLASD4 (as called by DLASD3). This routine also calculates the singular vectors of the current problem. The final stage consists of computing the updated singular vectors directly using the updated singular values. The singular vectors for the current problem are multiplied with the singular vectors from the overall problem.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | nl | |||
| integer(kind=ilp), | intent(in) | :: | nr | |||
| integer(kind=ilp), | intent(in) | :: | sqre | |||
| real(kind=dp), | intent(inout) | :: | d(*) | |||
| real(kind=dp), | intent(inout) | :: | alpha | |||
| real(kind=dp), | intent(inout) | :: | beta | |||
| real(kind=dp), | intent(inout) | :: | u(ldu,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldu | |||
| real(kind=dp), | intent(inout) | :: | vt(ldvt,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldvt | |||
| integer(kind=ilp), | intent(inout) | :: | idxq(*) | |||
| integer(kind=ilp), | intent(out) | :: | iwork(*) | |||
| real(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
SLASD1 computes the SVD of an upper bidiagonal N-by-M matrix B, where N = NL + NR + 1 and M = N + SQRE. SLASD1 is called from SLASD0. A related subroutine SLASD7 handles the case in which the singular values (and the singular vectors in factored form) are desired. SLASD1 computes the SVD as follows: ( D1(in) 0 0 0 ) B = U(in) * ( Z1T a Z2T b ) * VT(in) ( 0 0 D2(in) 0 ) = U(out) * ( D(out) 0) * VT(out) where ZT = (Z1T a Z2T b) = uT VT**T, and u is a vector of dimension M with ALPHA and BETA in the NL+1 and NL+2 th entries and zeros elsewhere; and the entry b is empty if SQRE = 0. The left singular vectors of the original matrix are stored in U, and the transpose of the right singular vectors are stored in VT, and the singular values are in D. The algorithm consists of three stages: The first stage consists of deflating the size of the problem when there are multiple singular values or when there are zeros in the Z vector. For each such occurrence the dimension of the secular equation problem is reduced by one. This stage is performed by the routine SLASD2. The second stage consists of calculating the updated singular values. This is done by finding the square roots of the roots of the secular equation via the routine SLASD4 (as called by SLASD3). This routine also calculates the singular vectors of the current problem. The final stage consists of computing the updated singular vectors directly using the updated singular values. The singular vectors for the current problem are multiplied with the singular vectors from the overall problem.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | nl | |||
| integer(kind=ilp), | intent(in) | :: | nr | |||
| integer(kind=ilp), | intent(in) | :: | sqre | |||
| real(kind=sp), | intent(inout) | :: | d(*) | |||
| real(kind=sp), | intent(inout) | :: | alpha | |||
| real(kind=sp), | intent(inout) | :: | beta | |||
| real(kind=sp), | intent(inout) | :: | u(ldu,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldu | |||
| real(kind=sp), | intent(inout) | :: | vt(ldvt,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldvt | |||
| integer(kind=ilp), | intent(inout) | :: | idxq(*) | |||
| integer(kind=ilp), | intent(out) | :: | iwork(*) | |||
| real(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
This subroutine computes the square root of the I-th updated eigenvalue of a positive symmetric rank-one modification to a positive diagonal matrix whose entries are given as the squares of the corresponding entries in the array d, and that 0 <= D(i) < D(j) for i < j and that RHO > 0. This is arranged by the calling routine, and is no loss in generality. The rank-one modified system is thus diag( D ) * diag( D ) + RHO * Z * Z_transpose. where we assume the Euclidean norm of Z is 1. The method consists of approximating the rational functions in the secular equation by simpler interpolating rational functions.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | i | |||
| real(kind=dp), | intent(in) | :: | d(*) | |||
| real(kind=dp), | intent(in) | :: | z(*) | |||
| real(kind=dp), | intent(out) | :: | delta(*) | |||
| real(kind=dp), | intent(in) | :: | rho | |||
| real(kind=dp), | intent(out) | :: | sigma | |||
| real(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | i | |||
| real(kind=sp), | intent(in) | :: | d(*) | |||
| real(kind=sp), | intent(in) | :: | z(*) | |||
| real(kind=sp), | intent(out) | :: | delta(*) | |||
| real(kind=sp), | intent(in) | :: | rho | |||
| real(kind=sp), | intent(out) | :: | sigma | |||
| real(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
This subroutine computes the square root of the I-th updated eigenvalue of a positive symmetric rank-one modification to a positive diagonal matrix whose entries are given as the squares of the corresponding entries in the array d, and that 0 <= D(i) < D(j) for i < j and that RHO > 0. This is arranged by the calling routine, and is no loss in generality. The rank-one modified system is thus diag( D ) * diag( D ) + RHO * Z * Z_transpose. where we assume the Euclidean norm of Z is 1. The method consists of approximating the rational functions in the secular equation by simpler interpolating rational functions.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | i | |||
| real(kind=dp), | intent(in) | :: | d(*) | |||
| real(kind=dp), | intent(in) | :: | z(*) | |||
| real(kind=dp), | intent(out) | :: | delta(*) | |||
| real(kind=dp), | intent(in) | :: | rho | |||
| real(kind=dp), | intent(out) | :: | sigma | |||
| real(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
This subroutine computes the square root of the I-th updated eigenvalue of a positive symmetric rank-one modification to a positive diagonal matrix whose entries are given as the squares of the corresponding entries in the array d, and that 0 <= D(i) < D(j) for i < j and that RHO > 0. This is arranged by the calling routine, and is no loss in generality. The rank-one modified system is thus diag( D ) * diag( D ) + RHO * Z * Z_transpose. where we assume the Euclidean norm of Z is 1. The method consists of approximating the rational functions in the secular equation by simpler interpolating rational functions.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | i | |||
| real(kind=sp), | intent(in) | :: | d(*) | |||
| real(kind=sp), | intent(in) | :: | z(*) | |||
| real(kind=sp), | intent(out) | :: | delta(*) | |||
| real(kind=sp), | intent(in) | :: | rho | |||
| real(kind=sp), | intent(out) | :: | sigma | |||
| real(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
This subroutine computes the square root of the I-th eigenvalue of a positive symmetric rank-one modification of a 2-by-2 diagonal matrix diag( D ) * diag( D ) + RHO * Z * transpose(Z) . The diagonal entries in the array D are assumed to satisfy 0 <= D(i) < D(j) for i < j . We also assume RHO > 0 and that the Euclidean norm of the vector Z is one.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | i | |||
| real(kind=dp), | intent(in) | :: | d(2) | |||
| real(kind=dp), | intent(in) | :: | z(2) | |||
| real(kind=dp), | intent(out) | :: | delta(2) | |||
| real(kind=dp), | intent(in) | :: | rho | |||
| real(kind=dp), | intent(out) | :: | dsigma | |||
| real(kind=dp), | intent(out) | :: | work(2) |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | i | |||
| real(kind=sp), | intent(in) | :: | d(2) | |||
| real(kind=sp), | intent(in) | :: | z(2) | |||
| real(kind=sp), | intent(out) | :: | delta(2) | |||
| real(kind=sp), | intent(in) | :: | rho | |||
| real(kind=sp), | intent(out) | :: | dsigma | |||
| real(kind=sp), | intent(out) | :: | work(2) |
This subroutine computes the square root of the I-th eigenvalue of a positive symmetric rank-one modification of a 2-by-2 diagonal matrix diag( D ) * diag( D ) + RHO * Z * transpose(Z) . The diagonal entries in the array D are assumed to satisfy 0 <= D(i) < D(j) for i < j . We also assume RHO > 0 and that the Euclidean norm of the vector Z is one.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | i | |||
| real(kind=dp), | intent(in) | :: | d(2) | |||
| real(kind=dp), | intent(in) | :: | z(2) | |||
| real(kind=dp), | intent(out) | :: | delta(2) | |||
| real(kind=dp), | intent(in) | :: | rho | |||
| real(kind=dp), | intent(out) | :: | dsigma | |||
| real(kind=dp), | intent(out) | :: | work(2) |
This subroutine computes the square root of the I-th eigenvalue of a positive symmetric rank-one modification of a 2-by-2 diagonal matrix diag( D ) * diag( D ) + RHO * Z * transpose(Z) . The diagonal entries in the array D are assumed to satisfy 0 <= D(i) < D(j) for i < j . We also assume RHO > 0 and that the Euclidean norm of the vector Z is one.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | i | |||
| real(kind=sp), | intent(in) | :: | d(2) | |||
| real(kind=sp), | intent(in) | :: | z(2) | |||
| real(kind=sp), | intent(out) | :: | delta(2) | |||
| real(kind=sp), | intent(in) | :: | rho | |||
| real(kind=sp), | intent(out) | :: | dsigma | |||
| real(kind=sp), | intent(out) | :: | work(2) |
LASD6 computes the SVD of an updated upper bidiagonal matrix B obtained by merging two smaller ones by appending a row. This routine is used only for the problem which requires all singular values and optionally singular vector matrices in factored form. B is an N-by-M matrix with N = NL + NR + 1 and M = N + SQRE. A related subroutine, DLASD1, handles the case in which all singular values and singular vectors of the bidiagonal matrix are desired. LASD6 computes the SVD as follows: ( D1(in) 0 0 0 ) B = U(in) * ( Z1T a Z2T b ) * VT(in) ( 0 0 D2(in) 0 ) = U(out) * ( D(out) 0) * VT(out) where ZT = (Z1T a Z2T b) = uT VT**T, and u is a vector of dimension M with ALPHA and BETA in the NL+1 and NL+2 th entries and zeros elsewhere; and the entry b is empty if SQRE = 0. The singular values of B can be computed using D1, D2, the first components of all the right singular vectors of the lower block, and the last components of all the right singular vectors of the upper block. These components are stored and updated in VF and VL, respectively, in LASD6. Hence U and VT are not explicitly referenced. The singular values are stored in D. The algorithm consists of two stages: The first stage consists of deflating the size of the problem when there are multiple singular values or if there is a zero in the Z vector. For each such occurrence the dimension of the secular equation problem is reduced by one. This stage is performed by the routine DLASD7. The second stage consists of calculating the updated singular values. This is done by finding the roots of the secular equation via the routine DLASD4 (as called by DLASD8). This routine also updates VF and VL and computes the distances between the updated singular values and the old singular values. LASD6 is called from DLASDA.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | icompq | |||
| integer(kind=ilp), | intent(in) | :: | nl | |||
| integer(kind=ilp), | intent(in) | :: | nr | |||
| integer(kind=ilp), | intent(in) | :: | sqre | |||
| real(kind=dp), | intent(inout) | :: | d(*) | |||
| real(kind=dp), | intent(inout) | :: | vf(*) | |||
| real(kind=dp), | intent(inout) | :: | vl(*) | |||
| real(kind=dp), | intent(inout) | :: | alpha | |||
| real(kind=dp), | intent(inout) | :: | beta | |||
| integer(kind=ilp), | intent(inout) | :: | idxq(*) | |||
| integer(kind=ilp), | intent(out) | :: | perm(*) | |||
| integer(kind=ilp), | intent(out) | :: | givptr | |||
| integer(kind=ilp), | intent(out) | :: | givcol(ldgcol,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldgcol | |||
| real(kind=dp), | intent(out) | :: | givnum(ldgnum,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldgnum | |||
| real(kind=dp), | intent(out) | :: | poles(ldgnum,*) | |||
| real(kind=dp), | intent(out) | :: | difl(*) | |||
| real(kind=dp), | intent(out) | :: | difr(*) | |||
| real(kind=dp), | intent(out) | :: | z(*) | |||
| integer(kind=ilp), | intent(out) | :: | k | |||
| real(kind=dp), | intent(out) | :: | c | |||
| real(kind=dp), | intent(out) | :: | s | |||
| real(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | iwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | icompq | |||
| integer(kind=ilp), | intent(in) | :: | nl | |||
| integer(kind=ilp), | intent(in) | :: | nr | |||
| integer(kind=ilp), | intent(in) | :: | sqre | |||
| real(kind=sp), | intent(inout) | :: | d(*) | |||
| real(kind=sp), | intent(inout) | :: | vf(*) | |||
| real(kind=sp), | intent(inout) | :: | vl(*) | |||
| real(kind=sp), | intent(inout) | :: | alpha | |||
| real(kind=sp), | intent(inout) | :: | beta | |||
| integer(kind=ilp), | intent(inout) | :: | idxq(*) | |||
| integer(kind=ilp), | intent(out) | :: | perm(*) | |||
| integer(kind=ilp), | intent(out) | :: | givptr | |||
| integer(kind=ilp), | intent(out) | :: | givcol(ldgcol,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldgcol | |||
| real(kind=sp), | intent(out) | :: | givnum(ldgnum,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldgnum | |||
| real(kind=sp), | intent(out) | :: | poles(ldgnum,*) | |||
| real(kind=sp), | intent(out) | :: | difl(*) | |||
| real(kind=sp), | intent(out) | :: | difr(*) | |||
| real(kind=sp), | intent(out) | :: | z(*) | |||
| integer(kind=ilp), | intent(out) | :: | k | |||
| real(kind=sp), | intent(out) | :: | c | |||
| real(kind=sp), | intent(out) | :: | s | |||
| real(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | iwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
DLASD6 computes the SVD of an updated upper bidiagonal matrix B obtained by merging two smaller ones by appending a row. This routine is used only for the problem which requires all singular values and optionally singular vector matrices in factored form. B is an N-by-M matrix with N = NL + NR + 1 and M = N + SQRE. A related subroutine, DLASD1, handles the case in which all singular values and singular vectors of the bidiagonal matrix are desired. DLASD6 computes the SVD as follows: ( D1(in) 0 0 0 ) B = U(in) * ( Z1T a Z2T b ) * VT(in) ( 0 0 D2(in) 0 ) = U(out) * ( D(out) 0) * VT(out) where ZT = (Z1T a Z2T b) = uT VT**T, and u is a vector of dimension M with ALPHA and BETA in the NL+1 and NL+2 th entries and zeros elsewhere; and the entry b is empty if SQRE = 0. The singular values of B can be computed using D1, D2, the first components of all the right singular vectors of the lower block, and the last components of all the right singular vectors of the upper block. These components are stored and updated in VF and VL, respectively, in DLASD6. Hence U and VT are not explicitly referenced. The singular values are stored in D. The algorithm consists of two stages: The first stage consists of deflating the size of the problem when there are multiple singular values or if there is a zero in the Z vector. For each such occurrence the dimension of the secular equation problem is reduced by one. This stage is performed by the routine DLASD7. The second stage consists of calculating the updated singular values. This is done by finding the roots of the secular equation via the routine DLASD4 (as called by DLASD8). This routine also updates VF and VL and computes the distances between the updated singular values and the old singular values. DLASD6 is called from DLASDA.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | icompq | |||
| integer(kind=ilp), | intent(in) | :: | nl | |||
| integer(kind=ilp), | intent(in) | :: | nr | |||
| integer(kind=ilp), | intent(in) | :: | sqre | |||
| real(kind=dp), | intent(inout) | :: | d(*) | |||
| real(kind=dp), | intent(inout) | :: | vf(*) | |||
| real(kind=dp), | intent(inout) | :: | vl(*) | |||
| real(kind=dp), | intent(inout) | :: | alpha | |||
| real(kind=dp), | intent(inout) | :: | beta | |||
| integer(kind=ilp), | intent(inout) | :: | idxq(*) | |||
| integer(kind=ilp), | intent(out) | :: | perm(*) | |||
| integer(kind=ilp), | intent(out) | :: | givptr | |||
| integer(kind=ilp), | intent(out) | :: | givcol(ldgcol,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldgcol | |||
| real(kind=dp), | intent(out) | :: | givnum(ldgnum,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldgnum | |||
| real(kind=dp), | intent(out) | :: | poles(ldgnum,*) | |||
| real(kind=dp), | intent(out) | :: | difl(*) | |||
| real(kind=dp), | intent(out) | :: | difr(*) | |||
| real(kind=dp), | intent(out) | :: | z(*) | |||
| integer(kind=ilp), | intent(out) | :: | k | |||
| real(kind=dp), | intent(out) | :: | c | |||
| real(kind=dp), | intent(out) | :: | s | |||
| real(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | iwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
SLASD6 computes the SVD of an updated upper bidiagonal matrix B obtained by merging two smaller ones by appending a row. This routine is used only for the problem which requires all singular values and optionally singular vector matrices in factored form. B is an N-by-M matrix with N = NL + NR + 1 and M = N + SQRE. A related subroutine, SLASD1, handles the case in which all singular values and singular vectors of the bidiagonal matrix are desired. SLASD6 computes the SVD as follows: ( D1(in) 0 0 0 ) B = U(in) * ( Z1T a Z2T b ) * VT(in) ( 0 0 D2(in) 0 ) = U(out) * ( D(out) 0) * VT(out) where ZT = (Z1T a Z2T b) = uT VT**T, and u is a vector of dimension M with ALPHA and BETA in the NL+1 and NL+2 th entries and zeros elsewhere; and the entry b is empty if SQRE = 0. The singular values of B can be computed using D1, D2, the first components of all the right singular vectors of the lower block, and the last components of all the right singular vectors of the upper block. These components are stored and updated in VF and VL, respectively, in SLASD6. Hence U and VT are not explicitly referenced. The singular values are stored in D. The algorithm consists of two stages: The first stage consists of deflating the size of the problem when there are multiple singular values or if there is a zero in the Z vector. For each such occurrence the dimension of the secular equation problem is reduced by one. This stage is performed by the routine SLASD7. The second stage consists of calculating the updated singular values. This is done by finding the roots of the secular equation via the routine SLASD4 (as called by SLASD8). This routine also updates VF and VL and computes the distances between the updated singular values and the old singular values. SLASD6 is called from SLASDA.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | icompq | |||
| integer(kind=ilp), | intent(in) | :: | nl | |||
| integer(kind=ilp), | intent(in) | :: | nr | |||
| integer(kind=ilp), | intent(in) | :: | sqre | |||
| real(kind=sp), | intent(inout) | :: | d(*) | |||
| real(kind=sp), | intent(inout) | :: | vf(*) | |||
| real(kind=sp), | intent(inout) | :: | vl(*) | |||
| real(kind=sp), | intent(inout) | :: | alpha | |||
| real(kind=sp), | intent(inout) | :: | beta | |||
| integer(kind=ilp), | intent(inout) | :: | idxq(*) | |||
| integer(kind=ilp), | intent(out) | :: | perm(*) | |||
| integer(kind=ilp), | intent(out) | :: | givptr | |||
| integer(kind=ilp), | intent(out) | :: | givcol(ldgcol,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldgcol | |||
| real(kind=sp), | intent(out) | :: | givnum(ldgnum,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldgnum | |||
| real(kind=sp), | intent(out) | :: | poles(ldgnum,*) | |||
| real(kind=sp), | intent(out) | :: | difl(*) | |||
| real(kind=sp), | intent(out) | :: | difr(*) | |||
| real(kind=sp), | intent(out) | :: | z(*) | |||
| integer(kind=ilp), | intent(out) | :: | k | |||
| real(kind=sp), | intent(out) | :: | c | |||
| real(kind=sp), | intent(out) | :: | s | |||
| real(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | iwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
LASD7 merges the two sets of singular values together into a single sorted set. Then it tries to deflate the size of the problem. There are two ways in which deflation can occur: when two or more singular values are close together or if there is a tiny entry in the Z vector. For each such occurrence the order of the related secular equation problem is reduced by one. LASD7 is called from DLASD6.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | icompq | |||
| integer(kind=ilp), | intent(in) | :: | nl | |||
| integer(kind=ilp), | intent(in) | :: | nr | |||
| integer(kind=ilp), | intent(in) | :: | sqre | |||
| integer(kind=ilp), | intent(out) | :: | k | |||
| real(kind=dp), | intent(inout) | :: | d(*) | |||
| real(kind=dp), | intent(out) | :: | z(*) | |||
| real(kind=dp), | intent(out) | :: | zw(*) | |||
| real(kind=dp), | intent(inout) | :: | vf(*) | |||
| real(kind=dp), | intent(out) | :: | vfw(*) | |||
| real(kind=dp), | intent(inout) | :: | vl(*) | |||
| real(kind=dp), | intent(out) | :: | vlw(*) | |||
| real(kind=dp), | intent(in) | :: | alpha | |||
| real(kind=dp), | intent(in) | :: | beta | |||
| real(kind=dp), | intent(out) | :: | dsigma(*) | |||
| integer(kind=ilp), | intent(out) | :: | idx(*) | |||
| integer(kind=ilp), | intent(out) | :: | idxp(*) | |||
| integer(kind=ilp), | intent(inout) | :: | idxq(*) | |||
| integer(kind=ilp), | intent(out) | :: | perm(*) | |||
| integer(kind=ilp), | intent(out) | :: | givptr | |||
| integer(kind=ilp), | intent(out) | :: | givcol(ldgcol,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldgcol | |||
| real(kind=dp), | intent(out) | :: | givnum(ldgnum,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldgnum | |||
| real(kind=dp), | intent(out) | :: | c | |||
| real(kind=dp), | intent(out) | :: | s | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | icompq | |||
| integer(kind=ilp), | intent(in) | :: | nl | |||
| integer(kind=ilp), | intent(in) | :: | nr | |||
| integer(kind=ilp), | intent(in) | :: | sqre | |||
| integer(kind=ilp), | intent(out) | :: | k | |||
| real(kind=sp), | intent(inout) | :: | d(*) | |||
| real(kind=sp), | intent(out) | :: | z(*) | |||
| real(kind=sp), | intent(out) | :: | zw(*) | |||
| real(kind=sp), | intent(inout) | :: | vf(*) | |||
| real(kind=sp), | intent(out) | :: | vfw(*) | |||
| real(kind=sp), | intent(inout) | :: | vl(*) | |||
| real(kind=sp), | intent(out) | :: | vlw(*) | |||
| real(kind=sp), | intent(in) | :: | alpha | |||
| real(kind=sp), | intent(in) | :: | beta | |||
| real(kind=sp), | intent(out) | :: | dsigma(*) | |||
| integer(kind=ilp), | intent(out) | :: | idx(*) | |||
| integer(kind=ilp), | intent(out) | :: | idxp(*) | |||
| integer(kind=ilp), | intent(inout) | :: | idxq(*) | |||
| integer(kind=ilp), | intent(out) | :: | perm(*) | |||
| integer(kind=ilp), | intent(out) | :: | givptr | |||
| integer(kind=ilp), | intent(out) | :: | givcol(ldgcol,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldgcol | |||
| real(kind=sp), | intent(out) | :: | givnum(ldgnum,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldgnum | |||
| real(kind=sp), | intent(out) | :: | c | |||
| real(kind=sp), | intent(out) | :: | s | |||
| integer(kind=ilp), | intent(out) | :: | info |
DLASD7 merges the two sets of singular values together into a single sorted set. Then it tries to deflate the size of the problem. There are two ways in which deflation can occur: when two or more singular values are close together or if there is a tiny entry in the Z vector. For each such occurrence the order of the related secular equation problem is reduced by one. DLASD7 is called from DLASD6.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | icompq | |||
| integer(kind=ilp), | intent(in) | :: | nl | |||
| integer(kind=ilp), | intent(in) | :: | nr | |||
| integer(kind=ilp), | intent(in) | :: | sqre | |||
| integer(kind=ilp), | intent(out) | :: | k | |||
| real(kind=dp), | intent(inout) | :: | d(*) | |||
| real(kind=dp), | intent(out) | :: | z(*) | |||
| real(kind=dp), | intent(out) | :: | zw(*) | |||
| real(kind=dp), | intent(inout) | :: | vf(*) | |||
| real(kind=dp), | intent(out) | :: | vfw(*) | |||
| real(kind=dp), | intent(inout) | :: | vl(*) | |||
| real(kind=dp), | intent(out) | :: | vlw(*) | |||
| real(kind=dp), | intent(in) | :: | alpha | |||
| real(kind=dp), | intent(in) | :: | beta | |||
| real(kind=dp), | intent(out) | :: | dsigma(*) | |||
| integer(kind=ilp), | intent(out) | :: | idx(*) | |||
| integer(kind=ilp), | intent(out) | :: | idxp(*) | |||
| integer(kind=ilp), | intent(inout) | :: | idxq(*) | |||
| integer(kind=ilp), | intent(out) | :: | perm(*) | |||
| integer(kind=ilp), | intent(out) | :: | givptr | |||
| integer(kind=ilp), | intent(out) | :: | givcol(ldgcol,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldgcol | |||
| real(kind=dp), | intent(out) | :: | givnum(ldgnum,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldgnum | |||
| real(kind=dp), | intent(out) | :: | c | |||
| real(kind=dp), | intent(out) | :: | s | |||
| integer(kind=ilp), | intent(out) | :: | info |
SLASD7 merges the two sets of singular values together into a single sorted set. Then it tries to deflate the size of the problem. There are two ways in which deflation can occur: when two or more singular values are close together or if there is a tiny entry in the Z vector. For each such occurrence the order of the related secular equation problem is reduced by one. SLASD7 is called from SLASD6.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | icompq | |||
| integer(kind=ilp), | intent(in) | :: | nl | |||
| integer(kind=ilp), | intent(in) | :: | nr | |||
| integer(kind=ilp), | intent(in) | :: | sqre | |||
| integer(kind=ilp), | intent(out) | :: | k | |||
| real(kind=sp), | intent(inout) | :: | d(*) | |||
| real(kind=sp), | intent(out) | :: | z(*) | |||
| real(kind=sp), | intent(out) | :: | zw(*) | |||
| real(kind=sp), | intent(inout) | :: | vf(*) | |||
| real(kind=sp), | intent(out) | :: | vfw(*) | |||
| real(kind=sp), | intent(inout) | :: | vl(*) | |||
| real(kind=sp), | intent(out) | :: | vlw(*) | |||
| real(kind=sp), | intent(in) | :: | alpha | |||
| real(kind=sp), | intent(in) | :: | beta | |||
| real(kind=sp), | intent(out) | :: | dsigma(*) | |||
| integer(kind=ilp), | intent(out) | :: | idx(*) | |||
| integer(kind=ilp), | intent(out) | :: | idxp(*) | |||
| integer(kind=ilp), | intent(inout) | :: | idxq(*) | |||
| integer(kind=ilp), | intent(out) | :: | perm(*) | |||
| integer(kind=ilp), | intent(out) | :: | givptr | |||
| integer(kind=ilp), | intent(out) | :: | givcol(ldgcol,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldgcol | |||
| real(kind=sp), | intent(out) | :: | givnum(ldgnum,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldgnum | |||
| real(kind=sp), | intent(out) | :: | c | |||
| real(kind=sp), | intent(out) | :: | s | |||
| integer(kind=ilp), | intent(out) | :: | info |
LASD8 finds the square roots of the roots of the secular equation, as defined by the values in DSIGMA and Z. It makes the appropriate calls to DLASD4, and stores, for each element in D, the distance to its two nearest poles (elements in DSIGMA). It also updates the arrays VF and VL, the first and last components of all the right singular vectors of the original bidiagonal matrix. LASD8 is called from DLASD6.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | icompq | |||
| integer(kind=ilp), | intent(in) | :: | k | |||
| real(kind=dp), | intent(out) | :: | d(*) | |||
| real(kind=dp), | intent(inout) | :: | z(*) | |||
| real(kind=dp), | intent(inout) | :: | vf(*) | |||
| real(kind=dp), | intent(inout) | :: | vl(*) | |||
| real(kind=dp), | intent(out) | :: | difl(*) | |||
| real(kind=dp), | intent(out) | :: | difr(lddifr,*) | |||
| integer(kind=ilp), | intent(in) | :: | lddifr | |||
| real(kind=dp), | intent(inout) | :: | dsigma(*) | |||
| real(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | icompq | |||
| integer(kind=ilp), | intent(in) | :: | k | |||
| real(kind=sp), | intent(out) | :: | d(*) | |||
| real(kind=sp), | intent(inout) | :: | z(*) | |||
| real(kind=sp), | intent(inout) | :: | vf(*) | |||
| real(kind=sp), | intent(inout) | :: | vl(*) | |||
| real(kind=sp), | intent(out) | :: | difl(*) | |||
| real(kind=sp), | intent(out) | :: | difr(lddifr,*) | |||
| integer(kind=ilp), | intent(in) | :: | lddifr | |||
| real(kind=sp), | intent(inout) | :: | dsigma(*) | |||
| real(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
DLASD8 finds the square roots of the roots of the secular equation, as defined by the values in DSIGMA and Z. It makes the appropriate calls to DLASD4, and stores, for each element in D, the distance to its two nearest poles (elements in DSIGMA). It also updates the arrays VF and VL, the first and last components of all the right singular vectors of the original bidiagonal matrix. DLASD8 is called from DLASD6.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | icompq | |||
| integer(kind=ilp), | intent(in) | :: | k | |||
| real(kind=dp), | intent(out) | :: | d(*) | |||
| real(kind=dp), | intent(inout) | :: | z(*) | |||
| real(kind=dp), | intent(inout) | :: | vf(*) | |||
| real(kind=dp), | intent(inout) | :: | vl(*) | |||
| real(kind=dp), | intent(out) | :: | difl(*) | |||
| real(kind=dp), | intent(out) | :: | difr(lddifr,*) | |||
| integer(kind=ilp), | intent(in) | :: | lddifr | |||
| real(kind=dp), | intent(inout) | :: | dsigma(*) | |||
| real(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
SLASD8 finds the square roots of the roots of the secular equation, as defined by the values in DSIGMA and Z. It makes the appropriate calls to SLASD4, and stores, for each element in D, the distance to its two nearest poles (elements in DSIGMA). It also updates the arrays VF and VL, the first and last components of all the right singular vectors of the original bidiagonal matrix. SLASD8 is called from SLASD6.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | icompq | |||
| integer(kind=ilp), | intent(in) | :: | k | |||
| real(kind=sp), | intent(out) | :: | d(*) | |||
| real(kind=sp), | intent(inout) | :: | z(*) | |||
| real(kind=sp), | intent(inout) | :: | vf(*) | |||
| real(kind=sp), | intent(inout) | :: | vl(*) | |||
| real(kind=sp), | intent(out) | :: | difl(*) | |||
| real(kind=sp), | intent(out) | :: | difr(lddifr,*) | |||
| integer(kind=ilp), | intent(in) | :: | lddifr | |||
| real(kind=sp), | intent(inout) | :: | dsigma(*) | |||
| real(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
Using a divide and conquer approach, LASDA: computes the singular value decomposition (SVD) of a real upper bidiagonal N-by-M matrix B with diagonal D and offdiagonal E, where M = N + SQRE. The algorithm computes the singular values in the SVD B = U * S * VT. The orthogonal matrices U and VT are optionally computed in compact form. A related subroutine, DLASD0, computes the singular values and the singular vectors in explicit form.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | icompq | |||
| integer(kind=ilp), | intent(in) | :: | smlsiz | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | sqre | |||
| real(kind=dp), | intent(inout) | :: | d(*) | |||
| real(kind=dp), | intent(inout) | :: | e(*) | |||
| real(kind=dp), | intent(out) | :: | u(ldu,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldu | |||
| real(kind=dp), | intent(out) | :: | vt(ldu,*) | |||
| integer(kind=ilp), | intent(out) | :: | k(*) | |||
| real(kind=dp), | intent(out) | :: | difl(ldu,*) | |||
| real(kind=dp), | intent(out) | :: | difr(ldu,*) | |||
| real(kind=dp), | intent(out) | :: | z(ldu,*) | |||
| real(kind=dp), | intent(out) | :: | poles(ldu,*) | |||
| integer(kind=ilp), | intent(out) | :: | givptr(*) | |||
| integer(kind=ilp), | intent(out) | :: | givcol(ldgcol,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldgcol | |||
| integer(kind=ilp), | intent(out) | :: | perm(ldgcol,*) | |||
| real(kind=dp), | intent(out) | :: | givnum(ldu,*) | |||
| real(kind=dp), | intent(out) | :: | c(*) | |||
| real(kind=dp), | intent(out) | :: | s(*) | |||
| real(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | iwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | icompq | |||
| integer(kind=ilp), | intent(in) | :: | smlsiz | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | sqre | |||
| real(kind=sp), | intent(inout) | :: | d(*) | |||
| real(kind=sp), | intent(inout) | :: | e(*) | |||
| real(kind=sp), | intent(out) | :: | u(ldu,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldu | |||
| real(kind=sp), | intent(out) | :: | vt(ldu,*) | |||
| integer(kind=ilp), | intent(out) | :: | k(*) | |||
| real(kind=sp), | intent(out) | :: | difl(ldu,*) | |||
| real(kind=sp), | intent(out) | :: | difr(ldu,*) | |||
| real(kind=sp), | intent(out) | :: | z(ldu,*) | |||
| real(kind=sp), | intent(out) | :: | poles(ldu,*) | |||
| integer(kind=ilp), | intent(out) | :: | givptr(*) | |||
| integer(kind=ilp), | intent(out) | :: | givcol(ldgcol,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldgcol | |||
| integer(kind=ilp), | intent(out) | :: | perm(ldgcol,*) | |||
| real(kind=sp), | intent(out) | :: | givnum(ldu,*) | |||
| real(kind=sp), | intent(out) | :: | c(*) | |||
| real(kind=sp), | intent(out) | :: | s(*) | |||
| real(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | iwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
Using a divide and conquer approach, DLASDA: computes the singular value decomposition (SVD) of a real upper bidiagonal N-by-M matrix B with diagonal D and offdiagonal E, where M = N + SQRE. The algorithm computes the singular values in the SVD B = U * S * VT. The orthogonal matrices U and VT are optionally computed in compact form. A related subroutine, DLASD0, computes the singular values and the singular vectors in explicit form.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | icompq | |||
| integer(kind=ilp), | intent(in) | :: | smlsiz | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | sqre | |||
| real(kind=dp), | intent(inout) | :: | d(*) | |||
| real(kind=dp), | intent(inout) | :: | e(*) | |||
| real(kind=dp), | intent(out) | :: | u(ldu,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldu | |||
| real(kind=dp), | intent(out) | :: | vt(ldu,*) | |||
| integer(kind=ilp), | intent(out) | :: | k(*) | |||
| real(kind=dp), | intent(out) | :: | difl(ldu,*) | |||
| real(kind=dp), | intent(out) | :: | difr(ldu,*) | |||
| real(kind=dp), | intent(out) | :: | z(ldu,*) | |||
| real(kind=dp), | intent(out) | :: | poles(ldu,*) | |||
| integer(kind=ilp), | intent(out) | :: | givptr(*) | |||
| integer(kind=ilp), | intent(out) | :: | givcol(ldgcol,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldgcol | |||
| integer(kind=ilp), | intent(out) | :: | perm(ldgcol,*) | |||
| real(kind=dp), | intent(out) | :: | givnum(ldu,*) | |||
| real(kind=dp), | intent(out) | :: | c(*) | |||
| real(kind=dp), | intent(out) | :: | s(*) | |||
| real(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | iwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
Using a divide and conquer approach, SLASDA: computes the singular value decomposition (SVD) of a real upper bidiagonal N-by-M matrix B with diagonal D and offdiagonal E, where M = N + SQRE. The algorithm computes the singular values in the SVD B = U * S * VT. The orthogonal matrices U and VT are optionally computed in compact form. A related subroutine, SLASD0, computes the singular values and the singular vectors in explicit form.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | icompq | |||
| integer(kind=ilp), | intent(in) | :: | smlsiz | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | sqre | |||
| real(kind=sp), | intent(inout) | :: | d(*) | |||
| real(kind=sp), | intent(inout) | :: | e(*) | |||
| real(kind=sp), | intent(out) | :: | u(ldu,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldu | |||
| real(kind=sp), | intent(out) | :: | vt(ldu,*) | |||
| integer(kind=ilp), | intent(out) | :: | k(*) | |||
| real(kind=sp), | intent(out) | :: | difl(ldu,*) | |||
| real(kind=sp), | intent(out) | :: | difr(ldu,*) | |||
| real(kind=sp), | intent(out) | :: | z(ldu,*) | |||
| real(kind=sp), | intent(out) | :: | poles(ldu,*) | |||
| integer(kind=ilp), | intent(out) | :: | givptr(*) | |||
| integer(kind=ilp), | intent(out) | :: | givcol(ldgcol,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldgcol | |||
| integer(kind=ilp), | intent(out) | :: | perm(ldgcol,*) | |||
| real(kind=sp), | intent(out) | :: | givnum(ldu,*) | |||
| real(kind=sp), | intent(out) | :: | c(*) | |||
| real(kind=sp), | intent(out) | :: | s(*) | |||
| real(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | iwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
LASDQ computes the singular value decomposition (SVD) of a real (upper or lower) bidiagonal matrix with diagonal D and offdiagonal E, accumulating the transformations if desired. Letting B denote the input bidiagonal matrix, the algorithm computes orthogonal matrices Q and P such that B = Q * S * PT (PT denotes the transpose of P). The singular values S are overwritten on D. The input matrix U is changed to U * Q if desired. The input matrix VT is changed to PT * VT if desired. The input matrix C is changed to QT * C if desired. See "Computing Small Singular Values of Bidiagonal Matrices With Guaranteed High Relative Accuracy," by J. Demmel and W. Kahan, LAPACK Working Note #3, for a detailed description of the algorithm.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | sqre | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | ncvt | |||
| integer(kind=ilp), | intent(in) | :: | nru | |||
| integer(kind=ilp), | intent(in) | :: | ncc | |||
| real(kind=dp), | intent(inout) | :: | d(*) | |||
| real(kind=dp), | intent(inout) | :: | e(*) | |||
| real(kind=dp), | intent(inout) | :: | vt(ldvt,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldvt | |||
| real(kind=dp), | intent(inout) | :: | u(ldu,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldu | |||
| real(kind=dp), | intent(inout) | :: | c(ldc,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldc | |||
| real(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | sqre | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | ncvt | |||
| integer(kind=ilp), | intent(in) | :: | nru | |||
| integer(kind=ilp), | intent(in) | :: | ncc | |||
| real(kind=sp), | intent(inout) | :: | d(*) | |||
| real(kind=sp), | intent(inout) | :: | e(*) | |||
| real(kind=sp), | intent(inout) | :: | vt(ldvt,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldvt | |||
| real(kind=sp), | intent(inout) | :: | u(ldu,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldu | |||
| real(kind=sp), | intent(inout) | :: | c(ldc,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldc | |||
| real(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
DLASDQ computes the singular value decomposition (SVD) of a real (upper or lower) bidiagonal matrix with diagonal D and offdiagonal E, accumulating the transformations if desired. Letting B denote the input bidiagonal matrix, the algorithm computes orthogonal matrices Q and P such that B = Q * S * PT (PT denotes the transpose of P). The singular values S are overwritten on D. The input matrix U is changed to U * Q if desired. The input matrix VT is changed to PT * VT if desired. The input matrix C is changed to QT * C if desired. See "Computing Small Singular Values of Bidiagonal Matrices With Guaranteed High Relative Accuracy," by J. Demmel and W. Kahan, LAPACK Working Note #3, for a detailed description of the algorithm.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | sqre | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | ncvt | |||
| integer(kind=ilp), | intent(in) | :: | nru | |||
| integer(kind=ilp), | intent(in) | :: | ncc | |||
| real(kind=dp), | intent(inout) | :: | d(*) | |||
| real(kind=dp), | intent(inout) | :: | e(*) | |||
| real(kind=dp), | intent(inout) | :: | vt(ldvt,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldvt | |||
| real(kind=dp), | intent(inout) | :: | u(ldu,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldu | |||
| real(kind=dp), | intent(inout) | :: | c(ldc,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldc | |||
| real(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
SLASDQ computes the singular value decomposition (SVD) of a real (upper or lower) bidiagonal matrix with diagonal D and offdiagonal E, accumulating the transformations if desired. Letting B denote the input bidiagonal matrix, the algorithm computes orthogonal matrices Q and P such that B = Q * S * PT (PT denotes the transpose of P). The singular values S are overwritten on D. The input matrix U is changed to U * Q if desired. The input matrix VT is changed to PT * VT if desired. The input matrix C is changed to QT * C if desired. See "Computing Small Singular Values of Bidiagonal Matrices With Guaranteed High Relative Accuracy," by J. Demmel and W. Kahan, LAPACK Working Note #3, for a detailed description of the algorithm.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | sqre | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | ncvt | |||
| integer(kind=ilp), | intent(in) | :: | nru | |||
| integer(kind=ilp), | intent(in) | :: | ncc | |||
| real(kind=sp), | intent(inout) | :: | d(*) | |||
| real(kind=sp), | intent(inout) | :: | e(*) | |||
| real(kind=sp), | intent(inout) | :: | vt(ldvt,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldvt | |||
| real(kind=sp), | intent(inout) | :: | u(ldu,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldu | |||
| real(kind=sp), | intent(inout) | :: | c(ldc,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldc | |||
| real(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
LASET initializes a 2-D array A to BETA on the diagonal and ALPHA on the offdiagonals.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=sp), | intent(in) | :: | alpha | |||
| complex(kind=sp), | intent(in) | :: | beta | |||
| complex(kind=sp), | intent(out) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=dp), | intent(in) | :: | alpha | |||
| real(kind=dp), | intent(in) | :: | beta | |||
| real(kind=dp), | intent(out) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=sp), | intent(in) | :: | alpha | |||
| real(kind=sp), | intent(in) | :: | beta | |||
| real(kind=sp), | intent(out) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=dp), | intent(in) | :: | alpha | |||
| complex(kind=dp), | intent(in) | :: | beta | |||
| complex(kind=dp), | intent(out) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda |
CLASET initializes a 2-D array A to BETA on the diagonal and ALPHA on the offdiagonals.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=sp), | intent(in) | :: | alpha | |||
| complex(kind=sp), | intent(in) | :: | beta | |||
| complex(kind=sp), | intent(out) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda |
DLASET initializes an m-by-n matrix A to BETA on the diagonal and ALPHA on the offdiagonals.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=dp), | intent(in) | :: | alpha | |||
| real(kind=dp), | intent(in) | :: | beta | |||
| real(kind=dp), | intent(out) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda |
SLASET initializes an m-by-n matrix A to BETA on the diagonal and ALPHA on the offdiagonals.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=sp), | intent(in) | :: | alpha | |||
| real(kind=sp), | intent(in) | :: | beta | |||
| real(kind=sp), | intent(out) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda |
ZLASET initializes a 2-D array A to BETA on the diagonal and ALPHA on the offdiagonals.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=dp), | intent(in) | :: | alpha | |||
| complex(kind=dp), | intent(in) | :: | beta | |||
| complex(kind=dp), | intent(out) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda |
LASQ1 computes the singular values of a real N-by-N bidiagonal matrix with diagonal D and off-diagonal E. The singular values are computed to high relative accuracy, in the absence of denormalization, underflow and overflow. The algorithm was first presented in "Accurate singular values and differential qd algorithms" by K. V. Fernando and B. N. Parlett, Numer. Math., Vol-67, No. 2, pp. 191-230, 1994, and the present implementation is described in "An implementation of the dqds Algorithm (Positive Case)", LAPACK Working Note.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=dp), | intent(inout) | :: | d(*) | |||
| real(kind=dp), | intent(inout) | :: | e(*) | |||
| real(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=sp), | intent(inout) | :: | d(*) | |||
| real(kind=sp), | intent(inout) | :: | e(*) | |||
| real(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
DLASQ1 computes the singular values of a real N-by-N bidiagonal matrix with diagonal D and off-diagonal E. The singular values are computed to high relative accuracy, in the absence of denormalization, underflow and overflow. The algorithm was first presented in "Accurate singular values and differential qd algorithms" by K. V. Fernando and B. N. Parlett, Numer. Math., Vol-67, No. 2, pp. 191-230, 1994, and the present implementation is described in "An implementation of the dqds Algorithm (Positive Case)", LAPACK Working Note.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=dp), | intent(inout) | :: | d(*) | |||
| real(kind=dp), | intent(inout) | :: | e(*) | |||
| real(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
SLASQ1 computes the singular values of a real N-by-N bidiagonal matrix with diagonal D and off-diagonal E. The singular values are computed to high relative accuracy, in the absence of denormalization, underflow and overflow. The algorithm was first presented in "Accurate singular values and differential qd algorithms" by K. V. Fernando and B. N. Parlett, Numer. Math., Vol-67, No. 2, pp. 191-230, 1994, and the present implementation is described in "An implementation of the dqds Algorithm (Positive Case)", LAPACK Working Note.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=sp), | intent(inout) | :: | d(*) | |||
| real(kind=sp), | intent(inout) | :: | e(*) | |||
| real(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
LASQ4 computes an approximation TAU to the smallest eigenvalue using values of d from the previous transform.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | i0 | |||
| integer(kind=ilp), | intent(in) | :: | n0 | |||
| real(kind=dp), | intent(in) | :: | z(*) | |||
| integer(kind=ilp), | intent(in) | :: | pp | |||
| integer(kind=ilp), | intent(in) | :: | n0in | |||
| real(kind=dp), | intent(in) | :: | dmin | |||
| real(kind=dp), | intent(in) | :: | dmin1 | |||
| real(kind=dp), | intent(in) | :: | dmin2 | |||
| real(kind=dp), | intent(in) | :: | dn | |||
| real(kind=dp), | intent(in) | :: | dn1 | |||
| real(kind=dp), | intent(in) | :: | dn2 | |||
| real(kind=dp), | intent(out) | :: | tau | |||
| integer(kind=ilp), | intent(out) | :: | ttype | |||
| real(kind=dp), | intent(inout) | :: | g |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | i0 | |||
| integer(kind=ilp), | intent(in) | :: | n0 | |||
| real(kind=sp), | intent(in) | :: | z(*) | |||
| integer(kind=ilp), | intent(in) | :: | pp | |||
| integer(kind=ilp), | intent(in) | :: | n0in | |||
| real(kind=sp), | intent(in) | :: | dmin | |||
| real(kind=sp), | intent(in) | :: | dmin1 | |||
| real(kind=sp), | intent(in) | :: | dmin2 | |||
| real(kind=sp), | intent(in) | :: | dn | |||
| real(kind=sp), | intent(in) | :: | dn1 | |||
| real(kind=sp), | intent(in) | :: | dn2 | |||
| real(kind=sp), | intent(out) | :: | tau | |||
| integer(kind=ilp), | intent(out) | :: | ttype | |||
| real(kind=sp), | intent(inout) | :: | g |
DLASQ4 computes an approximation TAU to the smallest eigenvalue using values of d from the previous transform.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | i0 | |||
| integer(kind=ilp), | intent(in) | :: | n0 | |||
| real(kind=dp), | intent(in) | :: | z(*) | |||
| integer(kind=ilp), | intent(in) | :: | pp | |||
| integer(kind=ilp), | intent(in) | :: | n0in | |||
| real(kind=dp), | intent(in) | :: | dmin | |||
| real(kind=dp), | intent(in) | :: | dmin1 | |||
| real(kind=dp), | intent(in) | :: | dmin2 | |||
| real(kind=dp), | intent(in) | :: | dn | |||
| real(kind=dp), | intent(in) | :: | dn1 | |||
| real(kind=dp), | intent(in) | :: | dn2 | |||
| real(kind=dp), | intent(out) | :: | tau | |||
| integer(kind=ilp), | intent(out) | :: | ttype | |||
| real(kind=dp), | intent(inout) | :: | g |
SLASQ4 computes an approximation TAU to the smallest eigenvalue using values of d from the previous transform.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | i0 | |||
| integer(kind=ilp), | intent(in) | :: | n0 | |||
| real(kind=sp), | intent(in) | :: | z(*) | |||
| integer(kind=ilp), | intent(in) | :: | pp | |||
| integer(kind=ilp), | intent(in) | :: | n0in | |||
| real(kind=sp), | intent(in) | :: | dmin | |||
| real(kind=sp), | intent(in) | :: | dmin1 | |||
| real(kind=sp), | intent(in) | :: | dmin2 | |||
| real(kind=sp), | intent(in) | :: | dn | |||
| real(kind=sp), | intent(in) | :: | dn1 | |||
| real(kind=sp), | intent(in) | :: | dn2 | |||
| real(kind=sp), | intent(out) | :: | tau | |||
| integer(kind=ilp), | intent(out) | :: | ttype | |||
| real(kind=sp), | intent(inout) | :: | g |
LASQ5 computes one dqds transform in ping-pong form, one version for IEEE machines another for non IEEE machines.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | i0 | |||
| integer(kind=ilp), | intent(in) | :: | n0 | |||
| real(kind=dp), | intent(inout) | :: | z(*) | |||
| integer(kind=ilp), | intent(in) | :: | pp | |||
| real(kind=dp), | intent(inout) | :: | tau | |||
| real(kind=dp), | intent(in) | :: | sigma | |||
| real(kind=dp), | intent(out) | :: | dmin | |||
| real(kind=dp), | intent(out) | :: | dmin1 | |||
| real(kind=dp), | intent(out) | :: | dmin2 | |||
| real(kind=dp), | intent(out) | :: | dn | |||
| real(kind=dp), | intent(out) | :: | dnm1 | |||
| real(kind=dp), | intent(out) | :: | dnm2 | |||
| logical(kind=lk), | intent(in) | :: | ieee | |||
| real(kind=dp), | intent(in) | :: | eps |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | i0 | |||
| integer(kind=ilp), | intent(in) | :: | n0 | |||
| real(kind=sp), | intent(inout) | :: | z(*) | |||
| integer(kind=ilp), | intent(in) | :: | pp | |||
| real(kind=sp), | intent(inout) | :: | tau | |||
| real(kind=sp), | intent(in) | :: | sigma | |||
| real(kind=sp), | intent(out) | :: | dmin | |||
| real(kind=sp), | intent(out) | :: | dmin1 | |||
| real(kind=sp), | intent(out) | :: | dmin2 | |||
| real(kind=sp), | intent(out) | :: | dn | |||
| real(kind=sp), | intent(out) | :: | dnm1 | |||
| real(kind=sp), | intent(out) | :: | dnm2 | |||
| logical(kind=lk), | intent(in) | :: | ieee | |||
| real(kind=sp), | intent(in) | :: | eps |
DLASQ5 computes one dqds transform in ping-pong form, one version for IEEE machines another for non IEEE machines.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | i0 | |||
| integer(kind=ilp), | intent(in) | :: | n0 | |||
| real(kind=dp), | intent(inout) | :: | z(*) | |||
| integer(kind=ilp), | intent(in) | :: | pp | |||
| real(kind=dp), | intent(inout) | :: | tau | |||
| real(kind=dp), | intent(in) | :: | sigma | |||
| real(kind=dp), | intent(out) | :: | dmin | |||
| real(kind=dp), | intent(out) | :: | dmin1 | |||
| real(kind=dp), | intent(out) | :: | dmin2 | |||
| real(kind=dp), | intent(out) | :: | dn | |||
| real(kind=dp), | intent(out) | :: | dnm1 | |||
| real(kind=dp), | intent(out) | :: | dnm2 | |||
| logical(kind=lk), | intent(in) | :: | ieee | |||
| real(kind=dp), | intent(in) | :: | eps |
SLASQ5 computes one dqds transform in ping-pong form, one version for IEEE machines another for non IEEE machines.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | i0 | |||
| integer(kind=ilp), | intent(in) | :: | n0 | |||
| real(kind=sp), | intent(inout) | :: | z(*) | |||
| integer(kind=ilp), | intent(in) | :: | pp | |||
| real(kind=sp), | intent(inout) | :: | tau | |||
| real(kind=sp), | intent(in) | :: | sigma | |||
| real(kind=sp), | intent(out) | :: | dmin | |||
| real(kind=sp), | intent(out) | :: | dmin1 | |||
| real(kind=sp), | intent(out) | :: | dmin2 | |||
| real(kind=sp), | intent(out) | :: | dn | |||
| real(kind=sp), | intent(out) | :: | dnm1 | |||
| real(kind=sp), | intent(out) | :: | dnm2 | |||
| logical(kind=lk), | intent(in) | :: | ieee | |||
| real(kind=sp), | intent(in) | :: | eps |
LASQ6 computes one dqd (shift equal to zero) transform in ping-pong form, with protection against underflow and overflow.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | i0 | |||
| integer(kind=ilp), | intent(in) | :: | n0 | |||
| real(kind=dp), | intent(inout) | :: | z(*) | |||
| integer(kind=ilp), | intent(in) | :: | pp | |||
| real(kind=dp), | intent(out) | :: | dmin | |||
| real(kind=dp), | intent(out) | :: | dmin1 | |||
| real(kind=dp), | intent(out) | :: | dmin2 | |||
| real(kind=dp), | intent(out) | :: | dn | |||
| real(kind=dp), | intent(out) | :: | dnm1 | |||
| real(kind=dp), | intent(out) | :: | dnm2 |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | i0 | |||
| integer(kind=ilp), | intent(in) | :: | n0 | |||
| real(kind=sp), | intent(inout) | :: | z(*) | |||
| integer(kind=ilp), | intent(in) | :: | pp | |||
| real(kind=sp), | intent(out) | :: | dmin | |||
| real(kind=sp), | intent(out) | :: | dmin1 | |||
| real(kind=sp), | intent(out) | :: | dmin2 | |||
| real(kind=sp), | intent(out) | :: | dn | |||
| real(kind=sp), | intent(out) | :: | dnm1 | |||
| real(kind=sp), | intent(out) | :: | dnm2 |
DLASQ6 computes one dqd (shift equal to zero) transform in ping-pong form, with protection against underflow and overflow.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | i0 | |||
| integer(kind=ilp), | intent(in) | :: | n0 | |||
| real(kind=dp), | intent(inout) | :: | z(*) | |||
| integer(kind=ilp), | intent(in) | :: | pp | |||
| real(kind=dp), | intent(out) | :: | dmin | |||
| real(kind=dp), | intent(out) | :: | dmin1 | |||
| real(kind=dp), | intent(out) | :: | dmin2 | |||
| real(kind=dp), | intent(out) | :: | dn | |||
| real(kind=dp), | intent(out) | :: | dnm1 | |||
| real(kind=dp), | intent(out) | :: | dnm2 |
SLASQ6 computes one dqd (shift equal to zero) transform in ping-pong form, with protection against underflow and overflow.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | i0 | |||
| integer(kind=ilp), | intent(in) | :: | n0 | |||
| real(kind=sp), | intent(inout) | :: | z(*) | |||
| integer(kind=ilp), | intent(in) | :: | pp | |||
| real(kind=sp), | intent(out) | :: | dmin | |||
| real(kind=sp), | intent(out) | :: | dmin1 | |||
| real(kind=sp), | intent(out) | :: | dmin2 | |||
| real(kind=sp), | intent(out) | :: | dn | |||
| real(kind=sp), | intent(out) | :: | dnm1 | |||
| real(kind=sp), | intent(out) | :: | dnm2 |
LASR applies a sequence of real plane rotations to a complex matrix A, from either the left or the right. When SIDE = 'L', the transformation takes the form A := PA and when SIDE = 'R', the transformation takes the form A := APT where P is an orthogonal matrix consisting of a sequence of z plane rotations, with z = M when SIDE = 'L' and z = N when SIDE = 'R', and PT is the transpose of P. When DIRECT = 'F' (Forward sequence), then P = P(z-1) * ... * P(2) * P(1) and when DIRECT = 'B' (Backward sequence), then P = P(1) * P(2) * ... * P(z-1) where P(k) is a plane rotation matrix defined by the 2-by-2 rotation R(k) = ( c(k) s(k) ) = ( -s(k) c(k) ). When PIVOT = 'V' (Variable pivot), the rotation is performed for the plane (k,k+1), i.e., P(k) has the form P(k) = ( 1 ) ( ... ) ( 1 ) ( c(k) s(k) ) ( -s(k) c(k) ) ( 1 ) ( ... ) ( 1 ) where R(k) appears as a rank-2 modification to the identity matrix in rows and columns k and k+1. When PIVOT = 'T' (Top pivot), the rotation is performed for the plane (1,k+1), so P(k) has the form P(k) = ( c(k) s(k) ) ( 1 ) ( ... ) ( 1 ) ( -s(k) c(k) ) ( 1 ) ( ... ) ( 1 ) where R(k) appears in rows and columns 1 and k+1. Similarly, when PIVOT = 'B' (Bottom pivot), the rotation is performed for the plane (k,z), giving P(k) the form P(k) = ( 1 ) ( ... ) ( 1 ) ( c(k) s(k) ) ( 1 ) ( ... ) ( 1 ) ( -s(k) c(k) ) where R(k) appears in rows and columns k and z. The rotations are performed without ever forming P(k) explicitly.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | side | |||
| character, | intent(in) | :: | pivot | |||
| character, | intent(in) | :: | direct | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=sp), | intent(in) | :: | c(*) | |||
| real(kind=sp), | intent(in) | :: | s(*) | |||
| complex(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | side | |||
| character, | intent(in) | :: | pivot | |||
| character, | intent(in) | :: | direct | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=dp), | intent(in) | :: | c(*) | |||
| real(kind=dp), | intent(in) | :: | s(*) | |||
| real(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | side | |||
| character, | intent(in) | :: | pivot | |||
| character, | intent(in) | :: | direct | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=sp), | intent(in) | :: | c(*) | |||
| real(kind=sp), | intent(in) | :: | s(*) | |||
| real(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | side | |||
| character, | intent(in) | :: | pivot | |||
| character, | intent(in) | :: | direct | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=dp), | intent(in) | :: | c(*) | |||
| real(kind=dp), | intent(in) | :: | s(*) | |||
| complex(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda |
CLASR applies a sequence of real plane rotations to a complex matrix A, from either the left or the right. When SIDE = 'L', the transformation takes the form A := PA and when SIDE = 'R', the transformation takes the form A := APT where P is an orthogonal matrix consisting of a sequence of z plane rotations, with z = M when SIDE = 'L' and z = N when SIDE = 'R', and PT is the transpose of P. When DIRECT = 'F' (Forward sequence), then P = P(z-1) * ... * P(2) * P(1) and when DIRECT = 'B' (Backward sequence), then P = P(1) * P(2) * ... * P(z-1) where P(k) is a plane rotation matrix defined by the 2-by-2 rotation R(k) = ( c(k) s(k) ) = ( -s(k) c(k) ). When PIVOT = 'V' (Variable pivot), the rotation is performed for the plane (k,k+1), i.e., P(k) has the form P(k) = ( 1 ) ( ... ) ( 1 ) ( c(k) s(k) ) ( -s(k) c(k) ) ( 1 ) ( ... ) ( 1 ) where R(k) appears as a rank-2 modification to the identity matrix in rows and columns k and k+1. When PIVOT = 'T' (Top pivot), the rotation is performed for the plane (1,k+1), so P(k) has the form P(k) = ( c(k) s(k) ) ( 1 ) ( ... ) ( 1 ) ( -s(k) c(k) ) ( 1 ) ( ... ) ( 1 ) where R(k) appears in rows and columns 1 and k+1. Similarly, when PIVOT = 'B' (Bottom pivot), the rotation is performed for the plane (k,z), giving P(k) the form P(k) = ( 1 ) ( ... ) ( 1 ) ( c(k) s(k) ) ( 1 ) ( ... ) ( 1 ) ( -s(k) c(k) ) where R(k) appears in rows and columns k and z. The rotations are performed without ever forming P(k) explicitly.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | side | |||
| character, | intent(in) | :: | pivot | |||
| character, | intent(in) | :: | direct | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=sp), | intent(in) | :: | c(*) | |||
| real(kind=sp), | intent(in) | :: | s(*) | |||
| complex(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda |
DLASR applies a sequence of plane rotations to a real matrix A, from either the left or the right. When SIDE = 'L', the transformation takes the form A := PA and when SIDE = 'R', the transformation takes the form A := APT where P is an orthogonal matrix consisting of a sequence of z plane rotations, with z = M when SIDE = 'L' and z = N when SIDE = 'R', and PT is the transpose of P. When DIRECT = 'F' (Forward sequence), then P = P(z-1) * ... * P(2) * P(1) and when DIRECT = 'B' (Backward sequence), then P = P(1) * P(2) * ... * P(z-1) where P(k) is a plane rotation matrix defined by the 2-by-2 rotation R(k) = ( c(k) s(k) ) = ( -s(k) c(k) ). When PIVOT = 'V' (Variable pivot), the rotation is performed for the plane (k,k+1), i.e., P(k) has the form P(k) = ( 1 ) ( ... ) ( 1 ) ( c(k) s(k) ) ( -s(k) c(k) ) ( 1 ) ( ... ) ( 1 ) where R(k) appears as a rank-2 modification to the identity matrix in rows and columns k and k+1. When PIVOT = 'T' (Top pivot), the rotation is performed for the plane (1,k+1), so P(k) has the form P(k) = ( c(k) s(k) ) ( 1 ) ( ... ) ( 1 ) ( -s(k) c(k) ) ( 1 ) ( ... ) ( 1 ) where R(k) appears in rows and columns 1 and k+1. Similarly, when PIVOT = 'B' (Bottom pivot), the rotation is performed for the plane (k,z), giving P(k) the form P(k) = ( 1 ) ( ... ) ( 1 ) ( c(k) s(k) ) ( 1 ) ( ... ) ( 1 ) ( -s(k) c(k) ) where R(k) appears in rows and columns k and z. The rotations are performed without ever forming P(k) explicitly.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | side | |||
| character, | intent(in) | :: | pivot | |||
| character, | intent(in) | :: | direct | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=dp), | intent(in) | :: | c(*) | |||
| real(kind=dp), | intent(in) | :: | s(*) | |||
| real(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda |
SLASR applies a sequence of plane rotations to a real matrix A, from either the left or the right. When SIDE = 'L', the transformation takes the form A := PA and when SIDE = 'R', the transformation takes the form A := APT where P is an orthogonal matrix consisting of a sequence of z plane rotations, with z = M when SIDE = 'L' and z = N when SIDE = 'R', and PT is the transpose of P. When DIRECT = 'F' (Forward sequence), then P = P(z-1) * ... * P(2) * P(1) and when DIRECT = 'B' (Backward sequence), then P = P(1) * P(2) * ... * P(z-1) where P(k) is a plane rotation matrix defined by the 2-by-2 rotation R(k) = ( c(k) s(k) ) = ( -s(k) c(k) ). When PIVOT = 'V' (Variable pivot), the rotation is performed for the plane (k,k+1), i.e., P(k) has the form P(k) = ( 1 ) ( ... ) ( 1 ) ( c(k) s(k) ) ( -s(k) c(k) ) ( 1 ) ( ... ) ( 1 ) where R(k) appears as a rank-2 modification to the identity matrix in rows and columns k and k+1. When PIVOT = 'T' (Top pivot), the rotation is performed for the plane (1,k+1), so P(k) has the form P(k) = ( c(k) s(k) ) ( 1 ) ( ... ) ( 1 ) ( -s(k) c(k) ) ( 1 ) ( ... ) ( 1 ) where R(k) appears in rows and columns 1 and k+1. Similarly, when PIVOT = 'B' (Bottom pivot), the rotation is performed for the plane (k,z), giving P(k) the form P(k) = ( 1 ) ( ... ) ( 1 ) ( c(k) s(k) ) ( 1 ) ( ... ) ( 1 ) ( -s(k) c(k) ) where R(k) appears in rows and columns k and z. The rotations are performed without ever forming P(k) explicitly.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | side | |||
| character, | intent(in) | :: | pivot | |||
| character, | intent(in) | :: | direct | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=sp), | intent(in) | :: | c(*) | |||
| real(kind=sp), | intent(in) | :: | s(*) | |||
| real(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda |
ZLASR applies a sequence of real plane rotations to a complex matrix A, from either the left or the right. When SIDE = 'L', the transformation takes the form A := PA and when SIDE = 'R', the transformation takes the form A := APT where P is an orthogonal matrix consisting of a sequence of z plane rotations, with z = M when SIDE = 'L' and z = N when SIDE = 'R', and PT is the transpose of P. When DIRECT = 'F' (Forward sequence), then P = P(z-1) * ... * P(2) * P(1) and when DIRECT = 'B' (Backward sequence), then P = P(1) * P(2) * ... * P(z-1) where P(k) is a plane rotation matrix defined by the 2-by-2 rotation R(k) = ( c(k) s(k) ) = ( -s(k) c(k) ). When PIVOT = 'V' (Variable pivot), the rotation is performed for the plane (k,k+1), i.e., P(k) has the form P(k) = ( 1 ) ( ... ) ( 1 ) ( c(k) s(k) ) ( -s(k) c(k) ) ( 1 ) ( ... ) ( 1 ) where R(k) appears as a rank-2 modification to the identity matrix in rows and columns k and k+1. When PIVOT = 'T' (Top pivot), the rotation is performed for the plane (1,k+1), so P(k) has the form P(k) = ( c(k) s(k) ) ( 1 ) ( ... ) ( 1 ) ( -s(k) c(k) ) ( 1 ) ( ... ) ( 1 ) where R(k) appears in rows and columns 1 and k+1. Similarly, when PIVOT = 'B' (Bottom pivot), the rotation is performed for the plane (k,z), giving P(k) the form P(k) = ( 1 ) ( ... ) ( 1 ) ( c(k) s(k) ) ( 1 ) ( ... ) ( 1 ) ( -s(k) c(k) ) where R(k) appears in rows and columns k and z. The rotations are performed without ever forming P(k) explicitly.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | side | |||
| character, | intent(in) | :: | pivot | |||
| character, | intent(in) | :: | direct | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=dp), | intent(in) | :: | c(*) | |||
| real(kind=dp), | intent(in) | :: | s(*) | |||
| complex(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda |
Sort the numbers in D in increasing order (if ID = 'I') or in decreasing order (if ID = 'D' ). Use Quick Sort, reverting to Insertion sort on arrays of size <= 20. Dimension of STACK limits N to about 2**32.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | id | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=dp), | intent(inout) | :: | d(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | id | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=sp), | intent(inout) | :: | d(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
Sort the numbers in D in increasing order (if ID = 'I') or in decreasing order (if ID = 'D' ). Use Quick Sort, reverting to Insertion sort on arrays of size <= 20. Dimension of STACK limits N to about 2**32.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | id | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=dp), | intent(inout) | :: | d(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
Sort the numbers in D in increasing order (if ID = 'I') or in decreasing order (if ID = 'D' ). Use Quick Sort, reverting to Insertion sort on arrays of size <= 20. Dimension of STACK limits N to about 2**32.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | id | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=sp), | intent(inout) | :: | d(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
LASSQ returns the values scl and smsq such that ( scl2 )*smsq = x( 1 )2 +...+ x( n )2 + ( scale2 )sumsq, where x( i ) = X( 1 + ( i - 1 )INCX ). The value of sumsq is assumed to be non-negative. scale and sumsq must be supplied in SCALE and SUMSQ and scl and smsq are overwritten on SCALE and SUMSQ respectively. If scale * sqrt( sumsq ) > tbig then we require: scale >= sqrt( TINYEPS ) / sbig on entry, and if 0 < scale * sqrt( sumsq ) < tsml then we require: scale <= sqrt( HUGE ) / ssml on entry, where tbig -- upper threshold for values whose square is representable; sbig -- scaling constant for big numbers; \see la_constants.f90 tsml -- lower threshold for values whose square is representable; ssml -- scaling constant for small numbers; \see la_constants.f90 and TINYEPS -- tiniest representable number; HUGE -- biggest representable number.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=sp), | intent(in) | :: | x(*) | |||
| integer(kind=ilp), | intent(in) | :: | incx | |||
| real(kind=sp), | intent(inout) | :: | scl | |||
| real(kind=sp), | intent(inout) | :: | sumsq |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=dp), | intent(in) | :: | x(*) | |||
| integer(kind=ilp), | intent(in) | :: | incx | |||
| real(kind=dp), | intent(inout) | :: | scl | |||
| real(kind=dp), | intent(inout) | :: | sumsq |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=sp), | intent(in) | :: | x(*) | |||
| integer(kind=ilp), | intent(in) | :: | incx | |||
| real(kind=sp), | intent(inout) | :: | scl | |||
| real(kind=sp), | intent(inout) | :: | sumsq |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=dp), | intent(in) | :: | x(*) | |||
| integer(kind=ilp), | intent(in) | :: | incx | |||
| real(kind=dp), | intent(inout) | :: | scl | |||
| real(kind=dp), | intent(inout) | :: | sumsq |
CLASSQ returns the values scl and smsq such that ( scl2 )*smsq = x( 1 )2 +...+ x( n )2 + ( scale2 )sumsq, where x( i ) = X( 1 + ( i - 1 )INCX ). The value of sumsq is assumed to be non-negative. scale and sumsq must be supplied in SCALE and SUMSQ and scl and smsq are overwritten on SCALE and SUMSQ respectively. If scale * sqrt( sumsq ) > tbig then we require: scale >= sqrt( TINYEPS ) / sbig on entry, and if 0 < scale * sqrt( sumsq ) < tsml then we require: scale <= sqrt( HUGE ) / ssml on entry, where tbig -- upper threshold for values whose square is representable; sbig -- scaling constant for big numbers; \see la_constants.f90 tsml -- lower threshold for values whose square is representable; ssml -- scaling constant for small numbers; \see la_constants.f90 and TINYEPS -- tiniest representable number; HUGE -- biggest representable number.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=sp), | intent(in) | :: | x(*) | |||
| integer(kind=ilp), | intent(in) | :: | incx | |||
| real(kind=sp), | intent(inout) | :: | scl | |||
| real(kind=sp), | intent(inout) | :: | sumsq |
DLASSQ returns the values scl and smsq such that ( scl2 )*smsq = x( 1 )2 +...+ x( n )2 + ( scale2 )sumsq, where x( i ) = X( 1 + ( i - 1 )INCX ). The value of sumsq is assumed to be non-negative. scale and sumsq must be supplied in SCALE and SUMSQ and scl and smsq are overwritten on SCALE and SUMSQ respectively. If scale * sqrt( sumsq ) > tbig then we require: scale >= sqrt( TINYEPS ) / sbig on entry, and if 0 < scale * sqrt( sumsq ) < tsml then we require: scale <= sqrt( HUGE ) / ssml on entry, where tbig -- upper threshold for values whose square is representable; sbig -- scaling constant for big numbers; \see la_constants.f90 tsml -- lower threshold for values whose square is representable; ssml -- scaling constant for small numbers; \see la_constants.f90 and TINYEPS -- tiniest representable number; HUGE -- biggest representable number.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=dp), | intent(in) | :: | x(*) | |||
| integer(kind=ilp), | intent(in) | :: | incx | |||
| real(kind=dp), | intent(inout) | :: | scl | |||
| real(kind=dp), | intent(inout) | :: | sumsq |
SLASSQ returns the values scl and smsq such that ( scl2 )*smsq = x( 1 )2 +...+ x( n )2 + ( scale2 )sumsq, where x( i ) = X( 1 + ( i - 1 )INCX ). The value of sumsq is assumed to be non-negative. scale and sumsq must be supplied in SCALE and SUMSQ and scl and smsq are overwritten on SCALE and SUMSQ respectively. If scale * sqrt( sumsq ) > tbig then we require: scale >= sqrt( TINYEPS ) / sbig on entry, and if 0 < scale * sqrt( sumsq ) < tsml then we require: scale <= sqrt( HUGE ) / ssml on entry, where tbig -- upper threshold for values whose square is representable; sbig -- scaling constant for big numbers; \see la_constants.f90 tsml -- lower threshold for values whose square is representable; ssml -- scaling constant for small numbers; \see la_constants.f90 and TINYEPS -- tiniest representable number; HUGE -- biggest representable number.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=sp), | intent(in) | :: | x(*) | |||
| integer(kind=ilp), | intent(in) | :: | incx | |||
| real(kind=sp), | intent(inout) | :: | scl | |||
| real(kind=sp), | intent(inout) | :: | sumsq |
ZLASSQ returns the values scl and smsq such that ( scl2 )*smsq = x( 1 )2 +...+ x( n )2 + ( scale2 )sumsq, where x( i ) = X( 1 + ( i - 1 )INCX ). The value of sumsq is assumed to be non-negative. scale and sumsq must be supplied in SCALE and SUMSQ and scl and smsq are overwritten on SCALE and SUMSQ respectively. If scale * sqrt( sumsq ) > tbig then we require: scale >= sqrt( TINYEPS ) / sbig on entry, and if 0 < scale * sqrt( sumsq ) < tsml then we require: scale <= sqrt( HUGE ) / ssml on entry, where tbig -- upper threshold for values whose square is representable; sbig -- scaling constant for big numbers; \see la_constants.f90 tsml -- lower threshold for values whose square is representable; ssml -- scaling constant for small numbers; \see la_constants.f90 and TINYEPS -- tiniest representable number; HUGE -- biggest representable number.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=dp), | intent(in) | :: | x(*) | |||
| integer(kind=ilp), | intent(in) | :: | incx | |||
| real(kind=dp), | intent(inout) | :: | scl | |||
| real(kind=dp), | intent(inout) | :: | sumsq |
LASWLQ computes a blocked Tall-Skinny LQ factorization of a complex M-by-N matrix A for M <= N: A = ( L 0 ) * Q, where: Q is a n-by-N orthogonal matrix, stored on exit in an implicit form in the elements above the diagonal of the array A and in the elements of the array T; L is a lower-triangular M-by-M matrix stored on exit in the elements on and below the diagonal of the array A. 0 is a M-by-(N-M) zero matrix, if M < N, and is not stored.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | mb | |||
| integer(kind=ilp), | intent(in) | :: | nb | |||
| complex(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=sp), | intent(out) | :: | t(ldt,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldt | |||
| complex(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | mb | |||
| integer(kind=ilp), | intent(in) | :: | nb | |||
| real(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=dp), | intent(out) | :: | t(ldt,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldt | |||
| real(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | mb | |||
| integer(kind=ilp), | intent(in) | :: | nb | |||
| real(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=sp), | intent(out) | :: | t(ldt,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldt | |||
| real(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | mb | |||
| integer(kind=ilp), | intent(in) | :: | nb | |||
| complex(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=dp), | intent(out) | :: | t(ldt,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldt | |||
| complex(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
CLASWLQ computes a blocked Tall-Skinny LQ factorization of a complex M-by-N matrix A for M <= N: A = ( L 0 ) * Q, where: Q is a n-by-N orthogonal matrix, stored on exit in an implicit form in the elements above the diagonal of the array A and in the elements of the array T; L is a lower-triangular M-by-M matrix stored on exit in the elements on and below the diagonal of the array A. 0 is a M-by-(N-M) zero matrix, if M < N, and is not stored.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | mb | |||
| integer(kind=ilp), | intent(in) | :: | nb | |||
| complex(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=sp), | intent(out) | :: | t(ldt,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldt | |||
| complex(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
DLASWLQ computes a blocked Tall-Skinny LQ factorization of a real M-by-N matrix A for M <= N: A = ( L 0 ) * Q, where: Q is a n-by-N orthogonal matrix, stored on exit in an implicit form in the elements above the diagonal of the array A and in the elements of the array T; L is a lower-triangular M-by-M matrix stored on exit in the elements on and below the diagonal of the array A. 0 is a M-by-(N-M) zero matrix, if M < N, and is not stored.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | mb | |||
| integer(kind=ilp), | intent(in) | :: | nb | |||
| real(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=dp), | intent(out) | :: | t(ldt,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldt | |||
| real(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
SLASWLQ computes a blocked Tall-Skinny LQ factorization of a real M-by-N matrix A for M <= N: A = ( L 0 ) * Q, where: Q is a n-by-N orthogonal matrix, stored on exit in an implicit form in the elements above the diagonal of the array A and in the elements of the array T; L is a lower-triangular M-by-M matrix stored on exit in the elements on and below the diagonal of the array A. 0 is a M-by-(N-M) zero matrix, if M < N, and is not stored.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | mb | |||
| integer(kind=ilp), | intent(in) | :: | nb | |||
| real(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=sp), | intent(out) | :: | t(ldt,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldt | |||
| real(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
ZLASWLQ computes a blocked Tall-Skinny LQ factorization of a complexx M-by-N matrix A for M <= N: A = ( L 0 ) * Q, where: Q is a n-by-N orthogonal matrix, stored on exit in an implicit form in the elements above the diagonal of the array A and in the elements of the array T; L is a lower-triangular M-by-M matrix stored on exit in the elements on and below the diagonal of the array A. 0 is a M-by-(N-M) zero matrix, if M < N, and is not stored.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | mb | |||
| integer(kind=ilp), | intent(in) | :: | nb | |||
| complex(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=dp), | intent(out) | :: | t(ldt,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldt | |||
| complex(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
LASWP performs a series of row interchanges on the matrix A. One row interchange is initiated for each of rows K1 through K2 of A.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| integer(kind=ilp), | intent(in) | :: | k1 | |||
| integer(kind=ilp), | intent(in) | :: | k2 | |||
| integer(kind=ilp), | intent(in) | :: | ipiv(*) | |||
| integer(kind=ilp), | intent(in) | :: | incx |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| integer(kind=ilp), | intent(in) | :: | k1 | |||
| integer(kind=ilp), | intent(in) | :: | k2 | |||
| integer(kind=ilp), | intent(in) | :: | ipiv(*) | |||
| integer(kind=ilp), | intent(in) | :: | incx |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| integer(kind=ilp), | intent(in) | :: | k1 | |||
| integer(kind=ilp), | intent(in) | :: | k2 | |||
| integer(kind=ilp), | intent(in) | :: | ipiv(*) | |||
| integer(kind=ilp), | intent(in) | :: | incx |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| integer(kind=ilp), | intent(in) | :: | k1 | |||
| integer(kind=ilp), | intent(in) | :: | k2 | |||
| integer(kind=ilp), | intent(in) | :: | ipiv(*) | |||
| integer(kind=ilp), | intent(in) | :: | incx |
CLASWP performs a series of row interchanges on the matrix A. One row interchange is initiated for each of rows K1 through K2 of A.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| integer(kind=ilp), | intent(in) | :: | k1 | |||
| integer(kind=ilp), | intent(in) | :: | k2 | |||
| integer(kind=ilp), | intent(in) | :: | ipiv(*) | |||
| integer(kind=ilp), | intent(in) | :: | incx |
DLASWP performs a series of row interchanges on the matrix A. One row interchange is initiated for each of rows K1 through K2 of A.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| integer(kind=ilp), | intent(in) | :: | k1 | |||
| integer(kind=ilp), | intent(in) | :: | k2 | |||
| integer(kind=ilp), | intent(in) | :: | ipiv(*) | |||
| integer(kind=ilp), | intent(in) | :: | incx |
SLASWP performs a series of row interchanges on the matrix A. One row interchange is initiated for each of rows K1 through K2 of A.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| integer(kind=ilp), | intent(in) | :: | k1 | |||
| integer(kind=ilp), | intent(in) | :: | k2 | |||
| integer(kind=ilp), | intent(in) | :: | ipiv(*) | |||
| integer(kind=ilp), | intent(in) | :: | incx |
ZLASWP performs a series of row interchanges on the matrix A. One row interchange is initiated for each of rows K1 through K2 of A.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| integer(kind=ilp), | intent(in) | :: | k1 | |||
| integer(kind=ilp), | intent(in) | :: | k2 | |||
| integer(kind=ilp), | intent(in) | :: | ipiv(*) | |||
| integer(kind=ilp), | intent(in) | :: | incx |
LASYF computes a partial factorization of a complex symmetric matrix A using the Bunch-Kaufman diagonal pivoting method. The partial factorization has the form: A = ( I U12 ) ( A11 0 ) ( I 0 ) if UPLO = 'U', or: ( 0 U22 ) ( 0 D ) ( U12T U22T ) A = ( L11 0 ) ( D 0 ) ( L11T L21T ) if UPLO = 'L' ( L21 I ) ( 0 A22 ) ( 0 I ) where the order of D is at most NB. The actual order is returned in the argument KB, and is either NB or NB-1, or N if N <= NB. Note that U**T denotes the transpose of U. LASYF is an auxiliary routine called by CSYTRF. It uses blocked code (calling Level 3 BLAS) to update the submatrix A11 (if UPLO = 'U') or A22 (if UPLO = 'L').
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nb | |||
| integer(kind=ilp), | intent(out) | :: | kb | |||
| complex(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| integer(kind=ilp), | intent(out) | :: | ipiv(*) | |||
| complex(kind=sp), | intent(out) | :: | w(ldw,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldw | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nb | |||
| integer(kind=ilp), | intent(out) | :: | kb | |||
| real(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| integer(kind=ilp), | intent(out) | :: | ipiv(*) | |||
| real(kind=dp), | intent(out) | :: | w(ldw,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldw | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nb | |||
| integer(kind=ilp), | intent(out) | :: | kb | |||
| real(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| integer(kind=ilp), | intent(out) | :: | ipiv(*) | |||
| real(kind=sp), | intent(out) | :: | w(ldw,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldw | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nb | |||
| integer(kind=ilp), | intent(out) | :: | kb | |||
| complex(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| integer(kind=ilp), | intent(out) | :: | ipiv(*) | |||
| complex(kind=dp), | intent(out) | :: | w(ldw,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldw | |||
| integer(kind=ilp), | intent(out) | :: | info |
CLASYF computes a partial factorization of a complex symmetric matrix A using the Bunch-Kaufman diagonal pivoting method. The partial factorization has the form: A = ( I U12 ) ( A11 0 ) ( I 0 ) if UPLO = 'U', or: ( 0 U22 ) ( 0 D ) ( U12T U22T ) A = ( L11 0 ) ( D 0 ) ( L11T L21T ) if UPLO = 'L' ( L21 I ) ( 0 A22 ) ( 0 I ) where the order of D is at most NB. The actual order is returned in the argument KB, and is either NB or NB-1, or N if N <= NB. Note that U**T denotes the transpose of U. CLASYF is an auxiliary routine called by CSYTRF. It uses blocked code (calling Level 3 BLAS) to update the submatrix A11 (if UPLO = 'U') or A22 (if UPLO = 'L').
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nb | |||
| integer(kind=ilp), | intent(out) | :: | kb | |||
| complex(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| integer(kind=ilp), | intent(out) | :: | ipiv(*) | |||
| complex(kind=sp), | intent(out) | :: | w(ldw,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldw | |||
| integer(kind=ilp), | intent(out) | :: | info |
DLASYF computes a partial factorization of a real symmetric matrix A using the Bunch-Kaufman diagonal pivoting method. The partial factorization has the form: A = ( I U12 ) ( A11 0 ) ( I 0 ) if UPLO = 'U', or: ( 0 U22 ) ( 0 D ) ( U12T U22T ) A = ( L11 0 ) ( D 0 ) ( L11T L21T ) if UPLO = 'L' ( L21 I ) ( 0 A22 ) ( 0 I ) where the order of D is at most NB. The actual order is returned in the argument KB, and is either NB or NB-1, or N if N <= NB. DLASYF is an auxiliary routine called by DSYTRF. It uses blocked code (calling Level 3 BLAS) to update the submatrix A11 (if UPLO = 'U') or A22 (if UPLO = 'L').
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nb | |||
| integer(kind=ilp), | intent(out) | :: | kb | |||
| real(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| integer(kind=ilp), | intent(out) | :: | ipiv(*) | |||
| real(kind=dp), | intent(out) | :: | w(ldw,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldw | |||
| integer(kind=ilp), | intent(out) | :: | info |
SLASYF computes a partial factorization of a real symmetric matrix A using the Bunch-Kaufman diagonal pivoting method. The partial factorization has the form: A = ( I U12 ) ( A11 0 ) ( I 0 ) if UPLO = 'U', or: ( 0 U22 ) ( 0 D ) ( U12T U22T ) A = ( L11 0 ) ( D 0 ) ( L11T L21T ) if UPLO = 'L' ( L21 I ) ( 0 A22 ) ( 0 I ) where the order of D is at most NB. The actual order is returned in the argument KB, and is either NB or NB-1, or N if N <= NB. SLASYF is an auxiliary routine called by SSYTRF. It uses blocked code (calling Level 3 BLAS) to update the submatrix A11 (if UPLO = 'U') or A22 (if UPLO = 'L').
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nb | |||
| integer(kind=ilp), | intent(out) | :: | kb | |||
| real(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| integer(kind=ilp), | intent(out) | :: | ipiv(*) | |||
| real(kind=sp), | intent(out) | :: | w(ldw,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldw | |||
| integer(kind=ilp), | intent(out) | :: | info |
ZLASYF computes a partial factorization of a complex symmetric matrix A using the Bunch-Kaufman diagonal pivoting method. The partial factorization has the form: A = ( I U12 ) ( A11 0 ) ( I 0 ) if UPLO = 'U', or: ( 0 U22 ) ( 0 D ) ( U12T U22T ) A = ( L11 0 ) ( D 0 ) ( L11T L21T ) if UPLO = 'L' ( L21 I ) ( 0 A22 ) ( 0 I ) where the order of D is at most NB. The actual order is returned in the argument KB, and is either NB or NB-1, or N if N <= NB. Note that U**T denotes the transpose of U. ZLASYF is an auxiliary routine called by ZSYTRF. It uses blocked code (calling Level 3 BLAS) to update the submatrix A11 (if UPLO = 'U') or A22 (if UPLO = 'L').
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nb | |||
| integer(kind=ilp), | intent(out) | :: | kb | |||
| complex(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| integer(kind=ilp), | intent(out) | :: | ipiv(*) | |||
| complex(kind=dp), | intent(out) | :: | w(ldw,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldw | |||
| integer(kind=ilp), | intent(out) | :: | info |
DLATRF_AA factorizes a panel of a complex symmetric matrix A using the Aasen's algorithm. The panel consists of a set of NB rows of A when UPLO is U, or a set of NB columns when UPLO is L. In order to factorize the panel, the Aasen's algorithm requires the last row, or column, of the previous panel. The first row, or column, of A is set to be the first row, or column, of an identity matrix, which is used to factorize the first panel. The resulting J-th row of U, or J-th column of L, is stored in the (J-1)-th row, or column, of A (without the unit diagonals), while the diagonal and subdiagonal of A are overwritten by those of T.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | j1 | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | nb | |||
| complex(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| integer(kind=ilp), | intent(out) | :: | ipiv(*) | |||
| complex(kind=sp), | intent(inout) | :: | h(ldh,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldh | |||
| complex(kind=sp), | intent(out) | :: | work(*) |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | j1 | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | nb | |||
| real(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| integer(kind=ilp), | intent(out) | :: | ipiv(*) | |||
| real(kind=dp), | intent(inout) | :: | h(ldh,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldh | |||
| real(kind=dp), | intent(out) | :: | work(*) |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | j1 | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | nb | |||
| real(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| integer(kind=ilp), | intent(out) | :: | ipiv(*) | |||
| real(kind=sp), | intent(inout) | :: | h(ldh,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldh | |||
| real(kind=sp), | intent(out) | :: | work(*) |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | j1 | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | nb | |||
| complex(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| integer(kind=ilp), | intent(out) | :: | ipiv(*) | |||
| complex(kind=dp), | intent(inout) | :: | h(ldh,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldh | |||
| complex(kind=dp), | intent(out) | :: | work(*) |
DLATRF_AA factorizes a panel of a complex symmetric matrix A using the Aasen's algorithm. The panel consists of a set of NB rows of A when UPLO is U, or a set of NB columns when UPLO is L. In order to factorize the panel, the Aasen's algorithm requires the last row, or column, of the previous panel. The first row, or column, of A is set to be the first row, or column, of an identity matrix, which is used to factorize the first panel. The resulting J-th row of U, or J-th column of L, is stored in the (J-1)-th row, or column, of A (without the unit diagonals), while the diagonal and subdiagonal of A are overwritten by those of T.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | j1 | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | nb | |||
| complex(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| integer(kind=ilp), | intent(out) | :: | ipiv(*) | |||
| complex(kind=sp), | intent(inout) | :: | h(ldh,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldh | |||
| complex(kind=sp), | intent(out) | :: | work(*) |
DLATRF_AA factorizes a panel of a real symmetric matrix A using the Aasen's algorithm. The panel consists of a set of NB rows of A when UPLO is U, or a set of NB columns when UPLO is L. In order to factorize the panel, the Aasen's algorithm requires the last row, or column, of the previous panel. The first row, or column, of A is set to be the first row, or column, of an identity matrix, which is used to factorize the first panel. The resulting J-th row of U, or J-th column of L, is stored in the (J-1)-th row, or column, of A (without the unit diagonals), while the diagonal and subdiagonal of A are overwritten by those of T.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | j1 | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | nb | |||
| real(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| integer(kind=ilp), | intent(out) | :: | ipiv(*) | |||
| real(kind=dp), | intent(inout) | :: | h(ldh,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldh | |||
| real(kind=dp), | intent(out) | :: | work(*) |
DLATRF_AA factorizes a panel of a real symmetric matrix A using the Aasen's algorithm. The panel consists of a set of NB rows of A when UPLO is U, or a set of NB columns when UPLO is L. In order to factorize the panel, the Aasen's algorithm requires the last row, or column, of the previous panel. The first row, or column, of A is set to be the first row, or column, of an identity matrix, which is used to factorize the first panel. The resulting J-th row of U, or J-th column of L, is stored in the (J-1)-th row, or column, of A (without the unit diagonals), while the diagonal and subdiagonal of A are overwritten by those of T.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | j1 | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | nb | |||
| real(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| integer(kind=ilp), | intent(out) | :: | ipiv(*) | |||
| real(kind=sp), | intent(inout) | :: | h(ldh,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldh | |||
| real(kind=sp), | intent(out) | :: | work(*) |
DLATRF_AA factorizes a panel of a complex symmetric matrix A using the Aasen's algorithm. The panel consists of a set of NB rows of A when UPLO is U, or a set of NB columns when UPLO is L. In order to factorize the panel, the Aasen's algorithm requires the last row, or column, of the previous panel. The first row, or column, of A is set to be the first row, or column, of an identity matrix, which is used to factorize the first panel. The resulting J-th row of U, or J-th column of L, is stored in the (J-1)-th row, or column, of A (without the unit diagonals), while the diagonal and subdiagonal of A are overwritten by those of T.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | j1 | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | nb | |||
| complex(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| integer(kind=ilp), | intent(out) | :: | ipiv(*) | |||
| complex(kind=dp), | intent(inout) | :: | h(ldh,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldh | |||
| complex(kind=dp), | intent(out) | :: | work(*) |
LASYF_RK computes a partial factorization of a complex symmetric matrix A using the bounded Bunch-Kaufman (rook) diagonal pivoting method. The partial factorization has the form: A = ( I U12 ) ( A11 0 ) ( I 0 ) if UPLO = 'U', or: ( 0 U22 ) ( 0 D ) ( U12T U22T ) A = ( L11 0 ) ( D 0 ) ( L11T L21T ) if UPLO = 'L', ( L21 I ) ( 0 A22 ) ( 0 I ) where the order of D is at most NB. The actual order is returned in the argument KB, and is either NB or NB-1, or N if N <= NB. LASYF_RK is an auxiliary routine called by CSYTRF_RK. It uses blocked code (calling Level 3 BLAS) to update the submatrix A11 (if UPLO = 'U') or A22 (if UPLO = 'L').
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nb | |||
| integer(kind=ilp), | intent(out) | :: | kb | |||
| complex(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=sp), | intent(out) | :: | e(*) | |||
| integer(kind=ilp), | intent(out) | :: | ipiv(*) | |||
| complex(kind=sp), | intent(out) | :: | w(ldw,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldw | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nb | |||
| integer(kind=ilp), | intent(out) | :: | kb | |||
| real(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=dp), | intent(out) | :: | e(*) | |||
| integer(kind=ilp), | intent(out) | :: | ipiv(*) | |||
| real(kind=dp), | intent(out) | :: | w(ldw,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldw | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nb | |||
| integer(kind=ilp), | intent(out) | :: | kb | |||
| real(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=sp), | intent(out) | :: | e(*) | |||
| integer(kind=ilp), | intent(out) | :: | ipiv(*) | |||
| real(kind=sp), | intent(out) | :: | w(ldw,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldw | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nb | |||
| integer(kind=ilp), | intent(out) | :: | kb | |||
| complex(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=dp), | intent(out) | :: | e(*) | |||
| integer(kind=ilp), | intent(out) | :: | ipiv(*) | |||
| complex(kind=dp), | intent(out) | :: | w(ldw,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldw | |||
| integer(kind=ilp), | intent(out) | :: | info |
CLASYF_RK computes a partial factorization of a complex symmetric matrix A using the bounded Bunch-Kaufman (rook) diagonal pivoting method. The partial factorization has the form: A = ( I U12 ) ( A11 0 ) ( I 0 ) if UPLO = 'U', or: ( 0 U22 ) ( 0 D ) ( U12T U22T ) A = ( L11 0 ) ( D 0 ) ( L11T L21T ) if UPLO = 'L', ( L21 I ) ( 0 A22 ) ( 0 I ) where the order of D is at most NB. The actual order is returned in the argument KB, and is either NB or NB-1, or N if N <= NB. CLASYF_RK is an auxiliary routine called by CSYTRF_RK. It uses blocked code (calling Level 3 BLAS) to update the submatrix A11 (if UPLO = 'U') or A22 (if UPLO = 'L').
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nb | |||
| integer(kind=ilp), | intent(out) | :: | kb | |||
| complex(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=sp), | intent(out) | :: | e(*) | |||
| integer(kind=ilp), | intent(out) | :: | ipiv(*) | |||
| complex(kind=sp), | intent(out) | :: | w(ldw,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldw | |||
| integer(kind=ilp), | intent(out) | :: | info |
DLASYF_RK computes a partial factorization of a real symmetric matrix A using the bounded Bunch-Kaufman (rook) diagonal pivoting method. The partial factorization has the form: A = ( I U12 ) ( A11 0 ) ( I 0 ) if UPLO = 'U', or: ( 0 U22 ) ( 0 D ) ( U12T U22T ) A = ( L11 0 ) ( D 0 ) ( L11T L21T ) if UPLO = 'L', ( L21 I ) ( 0 A22 ) ( 0 I ) where the order of D is at most NB. The actual order is returned in the argument KB, and is either NB or NB-1, or N if N <= NB. DLASYF_RK is an auxiliary routine called by DSYTRF_RK. It uses blocked code (calling Level 3 BLAS) to update the submatrix A11 (if UPLO = 'U') or A22 (if UPLO = 'L').
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nb | |||
| integer(kind=ilp), | intent(out) | :: | kb | |||
| real(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=dp), | intent(out) | :: | e(*) | |||
| integer(kind=ilp), | intent(out) | :: | ipiv(*) | |||
| real(kind=dp), | intent(out) | :: | w(ldw,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldw | |||
| integer(kind=ilp), | intent(out) | :: | info |
SLASYF_RK computes a partial factorization of a real symmetric matrix A using the bounded Bunch-Kaufman (rook) diagonal pivoting method. The partial factorization has the form: A = ( I U12 ) ( A11 0 ) ( I 0 ) if UPLO = 'U', or: ( 0 U22 ) ( 0 D ) ( U12T U22T ) A = ( L11 0 ) ( D 0 ) ( L11T L21T ) if UPLO = 'L', ( L21 I ) ( 0 A22 ) ( 0 I ) where the order of D is at most NB. The actual order is returned in the argument KB, and is either NB or NB-1, or N if N <= NB. SLASYF_RK is an auxiliary routine called by SSYTRF_RK. It uses blocked code (calling Level 3 BLAS) to update the submatrix A11 (if UPLO = 'U') or A22 (if UPLO = 'L').
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nb | |||
| integer(kind=ilp), | intent(out) | :: | kb | |||
| real(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=sp), | intent(out) | :: | e(*) | |||
| integer(kind=ilp), | intent(out) | :: | ipiv(*) | |||
| real(kind=sp), | intent(out) | :: | w(ldw,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldw | |||
| integer(kind=ilp), | intent(out) | :: | info |
ZLASYF_RK computes a partial factorization of a complex symmetric matrix A using the bounded Bunch-Kaufman (rook) diagonal pivoting method. The partial factorization has the form: A = ( I U12 ) ( A11 0 ) ( I 0 ) if UPLO = 'U', or: ( 0 U22 ) ( 0 D ) ( U12T U22T ) A = ( L11 0 ) ( D 0 ) ( L11T L21T ) if UPLO = 'L', ( L21 I ) ( 0 A22 ) ( 0 I ) where the order of D is at most NB. The actual order is returned in the argument KB, and is either NB or NB-1, or N if N <= NB. ZLASYF_RK is an auxiliary routine called by ZSYTRF_RK. It uses blocked code (calling Level 3 BLAS) to update the submatrix A11 (if UPLO = 'U') or A22 (if UPLO = 'L').
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nb | |||
| integer(kind=ilp), | intent(out) | :: | kb | |||
| complex(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=dp), | intent(out) | :: | e(*) | |||
| integer(kind=ilp), | intent(out) | :: | ipiv(*) | |||
| complex(kind=dp), | intent(out) | :: | w(ldw,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldw | |||
| integer(kind=ilp), | intent(out) | :: | info |
LASYF_ROOK computes a partial factorization of a complex symmetric matrix A using the bounded Bunch-Kaufman ("rook") diagonal pivoting method. The partial factorization has the form: A = ( I U12 ) ( A11 0 ) ( I 0 ) if UPLO = 'U', or: ( 0 U22 ) ( 0 D ) ( U12T U22T ) A = ( L11 0 ) ( D 0 ) ( L11T L21T ) if UPLO = 'L' ( L21 I ) ( 0 A22 ) ( 0 I ) where the order of D is at most NB. The actual order is returned in the argument KB, and is either NB or NB-1, or N if N <= NB. LASYF_ROOK is an auxiliary routine called by CSYTRF_ROOK. It uses blocked code (calling Level 3 BLAS) to update the submatrix A11 (if UPLO = 'U') or A22 (if UPLO = 'L').
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nb | |||
| integer(kind=ilp), | intent(out) | :: | kb | |||
| complex(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| integer(kind=ilp), | intent(out) | :: | ipiv(*) | |||
| complex(kind=sp), | intent(out) | :: | w(ldw,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldw | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nb | |||
| integer(kind=ilp), | intent(out) | :: | kb | |||
| real(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| integer(kind=ilp), | intent(out) | :: | ipiv(*) | |||
| real(kind=dp), | intent(out) | :: | w(ldw,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldw | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nb | |||
| integer(kind=ilp), | intent(out) | :: | kb | |||
| real(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| integer(kind=ilp), | intent(out) | :: | ipiv(*) | |||
| real(kind=sp), | intent(out) | :: | w(ldw,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldw | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nb | |||
| integer(kind=ilp), | intent(out) | :: | kb | |||
| complex(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| integer(kind=ilp), | intent(out) | :: | ipiv(*) | |||
| complex(kind=dp), | intent(out) | :: | w(ldw,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldw | |||
| integer(kind=ilp), | intent(out) | :: | info |
CLASYF_ROOK computes a partial factorization of a complex symmetric matrix A using the bounded Bunch-Kaufman ("rook") diagonal pivoting method. The partial factorization has the form: A = ( I U12 ) ( A11 0 ) ( I 0 ) if UPLO = 'U', or: ( 0 U22 ) ( 0 D ) ( U12T U22T ) A = ( L11 0 ) ( D 0 ) ( L11T L21T ) if UPLO = 'L' ( L21 I ) ( 0 A22 ) ( 0 I ) where the order of D is at most NB. The actual order is returned in the argument KB, and is either NB or NB-1, or N if N <= NB. CLASYF_ROOK is an auxiliary routine called by CSYTRF_ROOK. It uses blocked code (calling Level 3 BLAS) to update the submatrix A11 (if UPLO = 'U') or A22 (if UPLO = 'L').
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nb | |||
| integer(kind=ilp), | intent(out) | :: | kb | |||
| complex(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| integer(kind=ilp), | intent(out) | :: | ipiv(*) | |||
| complex(kind=sp), | intent(out) | :: | w(ldw,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldw | |||
| integer(kind=ilp), | intent(out) | :: | info |
DLASYF_ROOK computes a partial factorization of a real symmetric matrix A using the bounded Bunch-Kaufman ("rook") diagonal pivoting method. The partial factorization has the form: A = ( I U12 ) ( A11 0 ) ( I 0 ) if UPLO = 'U', or: ( 0 U22 ) ( 0 D ) ( U12T U22T ) A = ( L11 0 ) ( D 0 ) ( L11T L21T ) if UPLO = 'L' ( L21 I ) ( 0 A22 ) ( 0 I ) where the order of D is at most NB. The actual order is returned in the argument KB, and is either NB or NB-1, or N if N <= NB. DLASYF_ROOK is an auxiliary routine called by DSYTRF_ROOK. It uses blocked code (calling Level 3 BLAS) to update the submatrix A11 (if UPLO = 'U') or A22 (if UPLO = 'L').
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nb | |||
| integer(kind=ilp), | intent(out) | :: | kb | |||
| real(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| integer(kind=ilp), | intent(out) | :: | ipiv(*) | |||
| real(kind=dp), | intent(out) | :: | w(ldw,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldw | |||
| integer(kind=ilp), | intent(out) | :: | info |
SLASYF_ROOK computes a partial factorization of a real symmetric matrix A using the bounded Bunch-Kaufman ("rook") diagonal pivoting method. The partial factorization has the form: A = ( I U12 ) ( A11 0 ) ( I 0 ) if UPLO = 'U', or: ( 0 U22 ) ( 0 D ) ( U12T U22T ) A = ( L11 0 ) ( D 0 ) ( L11T L21T ) if UPLO = 'L' ( L21 I ) ( 0 A22 ) ( 0 I ) where the order of D is at most NB. The actual order is returned in the argument KB, and is either NB or NB-1, or N if N <= NB. SLASYF_ROOK is an auxiliary routine called by SSYTRF_ROOK. It uses blocked code (calling Level 3 BLAS) to update the submatrix A11 (if UPLO = 'U') or A22 (if UPLO = 'L').
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nb | |||
| integer(kind=ilp), | intent(out) | :: | kb | |||
| real(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| integer(kind=ilp), | intent(out) | :: | ipiv(*) | |||
| real(kind=sp), | intent(out) | :: | w(ldw,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldw | |||
| integer(kind=ilp), | intent(out) | :: | info |
ZLASYF_ROOK computes a partial factorization of a complex symmetric matrix A using the bounded Bunch-Kaufman ("rook") diagonal pivoting method. The partial factorization has the form: A = ( I U12 ) ( A11 0 ) ( I 0 ) if UPLO = 'U', or: ( 0 U22 ) ( 0 D ) ( U12T U22T ) A = ( L11 0 ) ( D 0 ) ( L11T L21T ) if UPLO = 'L' ( L21 I ) ( 0 A22 ) ( 0 I ) where the order of D is at most NB. The actual order is returned in the argument KB, and is either NB or NB-1, or N if N <= NB. ZLASYF_ROOK is an auxiliary routine called by ZSYTRF_ROOK. It uses blocked code (calling Level 3 BLAS) to update the submatrix A11 (if UPLO = 'U') or A22 (if UPLO = 'L').
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nb | |||
| integer(kind=ilp), | intent(out) | :: | kb | |||
| complex(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| integer(kind=ilp), | intent(out) | :: | ipiv(*) | |||
| complex(kind=dp), | intent(out) | :: | w(ldw,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldw | |||
| integer(kind=ilp), | intent(out) | :: | info |
LATBS solves one of the triangular systems A * x = sb, AT * x = sb, or AH * x = s*b, with scaling to prevent overflow, where A is an upper or lower triangular band matrix. Here AT denotes the transpose of A, x and b are n-element vectors, and s is a scaling factor, usually less than or equal to 1, chosen so that the components of x will be less than the overflow threshold. If the unscaled problem will not cause overflow, the Level 2 BLAS routine CTBSV is called. If the matrix A is singular (A(j,j) = 0 for some j), then s is set to 0 and a non-trivial solution to A*x = 0 is returned.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| character, | intent(in) | :: | trans | |||
| character, | intent(in) | :: | diag | |||
| character, | intent(in) | :: | normin | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | kd | |||
| complex(kind=sp), | intent(in) | :: | ab(ldab,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldab | |||
| complex(kind=sp), | intent(inout) | :: | x(*) | |||
| real(kind=sp), | intent(out) | :: | scale | |||
| real(kind=sp), | intent(inout) | :: | cnorm(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| character, | intent(in) | :: | trans | |||
| character, | intent(in) | :: | diag | |||
| character, | intent(in) | :: | normin | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | kd | |||
| real(kind=dp), | intent(in) | :: | ab(ldab,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldab | |||
| real(kind=dp), | intent(inout) | :: | x(*) | |||
| real(kind=dp), | intent(out) | :: | scale | |||
| real(kind=dp), | intent(inout) | :: | cnorm(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| character, | intent(in) | :: | trans | |||
| character, | intent(in) | :: | diag | |||
| character, | intent(in) | :: | normin | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | kd | |||
| real(kind=sp), | intent(in) | :: | ab(ldab,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldab | |||
| real(kind=sp), | intent(inout) | :: | x(*) | |||
| real(kind=sp), | intent(out) | :: | scale | |||
| real(kind=sp), | intent(inout) | :: | cnorm(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| character, | intent(in) | :: | trans | |||
| character, | intent(in) | :: | diag | |||
| character, | intent(in) | :: | normin | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | kd | |||
| complex(kind=dp), | intent(in) | :: | ab(ldab,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldab | |||
| complex(kind=dp), | intent(inout) | :: | x(*) | |||
| real(kind=dp), | intent(out) | :: | scale | |||
| real(kind=dp), | intent(inout) | :: | cnorm(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
CLATBS solves one of the triangular systems A * x = sb, AT * x = sb, or AH * x = s*b, with scaling to prevent overflow, where A is an upper or lower triangular band matrix. Here AT denotes the transpose of A, x and b are n-element vectors, and s is a scaling factor, usually less than or equal to 1, chosen so that the components of x will be less than the overflow threshold. If the unscaled problem will not cause overflow, the Level 2 BLAS routine CTBSV is called. If the matrix A is singular (A(j,j) = 0 for some j), then s is set to 0 and a non-trivial solution to A*x = 0 is returned.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| character, | intent(in) | :: | trans | |||
| character, | intent(in) | :: | diag | |||
| character, | intent(in) | :: | normin | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | kd | |||
| complex(kind=sp), | intent(in) | :: | ab(ldab,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldab | |||
| complex(kind=sp), | intent(inout) | :: | x(*) | |||
| real(kind=sp), | intent(out) | :: | scale | |||
| real(kind=sp), | intent(inout) | :: | cnorm(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
DLATBS solves one of the triangular systems A x = sb or ATx = sb with scaling to prevent overflow, where A is an upper or lower triangular band matrix. Here AT denotes the transpose of A, x and b are n-element vectors, and s is a scaling factor, usually less than or equal to 1, chosen so that the components of x will be less than the overflow threshold. If the unscaled problem will not cause overflow, the Level 2 BLAS routine DTBSV is called. If the matrix A is singular (A(j,j) = 0 for some j), then s is set to 0 and a non-trivial solution to A*x = 0 is returned.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| character, | intent(in) | :: | trans | |||
| character, | intent(in) | :: | diag | |||
| character, | intent(in) | :: | normin | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | kd | |||
| real(kind=dp), | intent(in) | :: | ab(ldab,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldab | |||
| real(kind=dp), | intent(inout) | :: | x(*) | |||
| real(kind=dp), | intent(out) | :: | scale | |||
| real(kind=dp), | intent(inout) | :: | cnorm(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
SLATBS solves one of the triangular systems A x = sb or ATx = sb with scaling to prevent overflow, where A is an upper or lower triangular band matrix. Here AT denotes the transpose of A, x and b are n-element vectors, and s is a scaling factor, usually less than or equal to 1, chosen so that the components of x will be less than the overflow threshold. If the unscaled problem will not cause overflow, the Level 2 BLAS routine STBSV is called. If the matrix A is singular (A(j,j) = 0 for some j), then s is set to 0 and a non-trivial solution to A*x = 0 is returned.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| character, | intent(in) | :: | trans | |||
| character, | intent(in) | :: | diag | |||
| character, | intent(in) | :: | normin | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | kd | |||
| real(kind=sp), | intent(in) | :: | ab(ldab,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldab | |||
| real(kind=sp), | intent(inout) | :: | x(*) | |||
| real(kind=sp), | intent(out) | :: | scale | |||
| real(kind=sp), | intent(inout) | :: | cnorm(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
ZLATBS solves one of the triangular systems A * x = sb, AT * x = sb, or AH * x = s*b, with scaling to prevent overflow, where A is an upper or lower triangular band matrix. Here AT denotes the transpose of A, x and b are n-element vectors, and s is a scaling factor, usually less than or equal to 1, chosen so that the components of x will be less than the overflow threshold. If the unscaled problem will not cause overflow, the Level 2 BLAS routine ZTBSV is called. If the matrix A is singular (A(j,j) = 0 for some j), then s is set to 0 and a non-trivial solution to A*x = 0 is returned.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| character, | intent(in) | :: | trans | |||
| character, | intent(in) | :: | diag | |||
| character, | intent(in) | :: | normin | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | kd | |||
| complex(kind=dp), | intent(in) | :: | ab(ldab,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldab | |||
| complex(kind=dp), | intent(inout) | :: | x(*) | |||
| real(kind=dp), | intent(out) | :: | scale | |||
| real(kind=dp), | intent(inout) | :: | cnorm(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
LATDF computes the contribution to the reciprocal Dif-estimate by solving for x in Z * x = b, where b is chosen such that the norm of x is as large as possible. It is assumed that LU decomposition of Z has been computed by CGETC2. On entry RHS = f holds the contribution from earlier solved sub-systems, and on return RHS = x. The factorization of Z returned by CGETC2 has the form Z = P * L * U * Q, where P and Q are permutation matrices. L is lower triangular with unit diagonal elements and U is upper triangular.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | ijob | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=sp), | intent(inout) | :: | z(ldz,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldz | |||
| complex(kind=sp), | intent(inout) | :: | rhs(*) | |||
| real(kind=sp), | intent(inout) | :: | rdsum | |||
| real(kind=sp), | intent(inout) | :: | rdscal | |||
| integer(kind=ilp), | intent(in) | :: | ipiv(*) | |||
| integer(kind=ilp), | intent(in) | :: | jpiv(*) |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | ijob | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=dp), | intent(inout) | :: | z(ldz,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldz | |||
| real(kind=dp), | intent(inout) | :: | rhs(*) | |||
| real(kind=dp), | intent(inout) | :: | rdsum | |||
| real(kind=dp), | intent(inout) | :: | rdscal | |||
| integer(kind=ilp), | intent(in) | :: | ipiv(*) | |||
| integer(kind=ilp), | intent(in) | :: | jpiv(*) |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | ijob | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=sp), | intent(inout) | :: | z(ldz,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldz | |||
| real(kind=sp), | intent(inout) | :: | rhs(*) | |||
| real(kind=sp), | intent(inout) | :: | rdsum | |||
| real(kind=sp), | intent(inout) | :: | rdscal | |||
| integer(kind=ilp), | intent(in) | :: | ipiv(*) | |||
| integer(kind=ilp), | intent(in) | :: | jpiv(*) |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | ijob | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=dp), | intent(inout) | :: | z(ldz,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldz | |||
| complex(kind=dp), | intent(inout) | :: | rhs(*) | |||
| real(kind=dp), | intent(inout) | :: | rdsum | |||
| real(kind=dp), | intent(inout) | :: | rdscal | |||
| integer(kind=ilp), | intent(in) | :: | ipiv(*) | |||
| integer(kind=ilp), | intent(in) | :: | jpiv(*) |
CLATDF computes the contribution to the reciprocal Dif-estimate by solving for x in Z * x = b, where b is chosen such that the norm of x is as large as possible. It is assumed that LU decomposition of Z has been computed by CGETC2. On entry RHS = f holds the contribution from earlier solved sub-systems, and on return RHS = x. The factorization of Z returned by CGETC2 has the form Z = P * L * U * Q, where P and Q are permutation matrices. L is lower triangular with unit diagonal elements and U is upper triangular.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | ijob | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=sp), | intent(inout) | :: | z(ldz,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldz | |||
| complex(kind=sp), | intent(inout) | :: | rhs(*) | |||
| real(kind=sp), | intent(inout) | :: | rdsum | |||
| real(kind=sp), | intent(inout) | :: | rdscal | |||
| integer(kind=ilp), | intent(in) | :: | ipiv(*) | |||
| integer(kind=ilp), | intent(in) | :: | jpiv(*) |
DLATDF uses the LU factorization of the n-by-n matrix Z computed by DGETC2 and computes a contribution to the reciprocal Dif-estimate by solving Z * x = b for x, and choosing the r.h.s. b such that the norm of x is as large as possible. On entry RHS = b holds the contribution from earlier solved sub-systems, and on return RHS = x. The factorization of Z returned by DGETC2 has the form Z = PLU*Q, where P and Q are permutation matrices. L is lower triangular with unit diagonal elements and U is upper triangular.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | ijob | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=dp), | intent(inout) | :: | z(ldz,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldz | |||
| real(kind=dp), | intent(inout) | :: | rhs(*) | |||
| real(kind=dp), | intent(inout) | :: | rdsum | |||
| real(kind=dp), | intent(inout) | :: | rdscal | |||
| integer(kind=ilp), | intent(in) | :: | ipiv(*) | |||
| integer(kind=ilp), | intent(in) | :: | jpiv(*) |
SLATDF uses the LU factorization of the n-by-n matrix Z computed by SGETC2 and computes a contribution to the reciprocal Dif-estimate by solving Z * x = b for x, and choosing the r.h.s. b such that the norm of x is as large as possible. On entry RHS = b holds the contribution from earlier solved sub-systems, and on return RHS = x. The factorization of Z returned by SGETC2 has the form Z = PLU*Q, where P and Q are permutation matrices. L is lower triangular with unit diagonal elements and U is upper triangular.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | ijob | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=sp), | intent(inout) | :: | z(ldz,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldz | |||
| real(kind=sp), | intent(inout) | :: | rhs(*) | |||
| real(kind=sp), | intent(inout) | :: | rdsum | |||
| real(kind=sp), | intent(inout) | :: | rdscal | |||
| integer(kind=ilp), | intent(in) | :: | ipiv(*) | |||
| integer(kind=ilp), | intent(in) | :: | jpiv(*) |
ZLATDF computes the contribution to the reciprocal Dif-estimate by solving for x in Z * x = b, where b is chosen such that the norm of x is as large as possible. It is assumed that LU decomposition of Z has been computed by ZGETC2. On entry RHS = f holds the contribution from earlier solved sub-systems, and on return RHS = x. The factorization of Z returned by ZGETC2 has the form Z = P * L * U * Q, where P and Q are permutation matrices. L is lower triangular with unit diagonal elements and U is upper triangular.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | ijob | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=dp), | intent(inout) | :: | z(ldz,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldz | |||
| complex(kind=dp), | intent(inout) | :: | rhs(*) | |||
| real(kind=dp), | intent(inout) | :: | rdsum | |||
| real(kind=dp), | intent(inout) | :: | rdscal | |||
| integer(kind=ilp), | intent(in) | :: | ipiv(*) | |||
| integer(kind=ilp), | intent(in) | :: | jpiv(*) |
LATPS solves one of the triangular systems A * x = sb, AT * x = sb, or AH * x = s*b, with scaling to prevent overflow, where A is an upper or lower triangular matrix stored in packed form. Here AT denotes the transpose of A, A*H denotes the conjugate transpose of A, x and b are n-element vectors, and s is a scaling factor, usually less than or equal to 1, chosen so that the components of x will be less than the overflow threshold. If the unscaled problem will not cause overflow, the Level 2 BLAS routine CTPSV is called. If the matrix A is singular (A(j,j) = 0 for some j), then s is set to 0 and a non-trivial solution to Ax = 0 is returned.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| character, | intent(in) | :: | trans | |||
| character, | intent(in) | :: | diag | |||
| character, | intent(in) | :: | normin | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=sp), | intent(in) | :: | ap(*) | |||
| complex(kind=sp), | intent(inout) | :: | x(*) | |||
| real(kind=sp), | intent(out) | :: | scale | |||
| real(kind=sp), | intent(inout) | :: | cnorm(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| character, | intent(in) | :: | trans | |||
| character, | intent(in) | :: | diag | |||
| character, | intent(in) | :: | normin | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=dp), | intent(in) | :: | ap(*) | |||
| real(kind=dp), | intent(inout) | :: | x(*) | |||
| real(kind=dp), | intent(out) | :: | scale | |||
| real(kind=dp), | intent(inout) | :: | cnorm(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| character, | intent(in) | :: | trans | |||
| character, | intent(in) | :: | diag | |||
| character, | intent(in) | :: | normin | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=sp), | intent(in) | :: | ap(*) | |||
| real(kind=sp), | intent(inout) | :: | x(*) | |||
| real(kind=sp), | intent(out) | :: | scale | |||
| real(kind=sp), | intent(inout) | :: | cnorm(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| character, | intent(in) | :: | trans | |||
| character, | intent(in) | :: | diag | |||
| character, | intent(in) | :: | normin | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=dp), | intent(in) | :: | ap(*) | |||
| complex(kind=dp), | intent(inout) | :: | x(*) | |||
| real(kind=dp), | intent(out) | :: | scale | |||
| real(kind=dp), | intent(inout) | :: | cnorm(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
CLATPS solves one of the triangular systems A * x = sb, AT * x = sb, or AH * x = s*b, with scaling to prevent overflow, where A is an upper or lower triangular matrix stored in packed form. Here AT denotes the transpose of A, A*H denotes the conjugate transpose of A, x and b are n-element vectors, and s is a scaling factor, usually less than or equal to 1, chosen so that the components of x will be less than the overflow threshold. If the unscaled problem will not cause overflow, the Level 2 BLAS routine CTPSV is called. If the matrix A is singular (A(j,j) = 0 for some j), then s is set to 0 and a non-trivial solution to Ax = 0 is returned.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| character, | intent(in) | :: | trans | |||
| character, | intent(in) | :: | diag | |||
| character, | intent(in) | :: | normin | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=sp), | intent(in) | :: | ap(*) | |||
| complex(kind=sp), | intent(inout) | :: | x(*) | |||
| real(kind=sp), | intent(out) | :: | scale | |||
| real(kind=sp), | intent(inout) | :: | cnorm(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
DLATPS solves one of the triangular systems A x = sb or ATx = sb with scaling to prevent overflow, where A is an upper or lower triangular matrix stored in packed form. Here AT denotes the transpose of A, x and b are n-element vectors, and s is a scaling factor, usually less than or equal to 1, chosen so that the components of x will be less than the overflow threshold. If the unscaled problem will not cause overflow, the Level 2 BLAS routine DTPSV is called. If the matrix A is singular (A(j,j) = 0 for some j), then s is set to 0 and a non-trivial solution to A*x = 0 is returned.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| character, | intent(in) | :: | trans | |||
| character, | intent(in) | :: | diag | |||
| character, | intent(in) | :: | normin | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=dp), | intent(in) | :: | ap(*) | |||
| real(kind=dp), | intent(inout) | :: | x(*) | |||
| real(kind=dp), | intent(out) | :: | scale | |||
| real(kind=dp), | intent(inout) | :: | cnorm(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
SLATPS solves one of the triangular systems A x = sb or ATx = sb with scaling to prevent overflow, where A is an upper or lower triangular matrix stored in packed form. Here AT denotes the transpose of A, x and b are n-element vectors, and s is a scaling factor, usually less than or equal to 1, chosen so that the components of x will be less than the overflow threshold. If the unscaled problem will not cause overflow, the Level 2 BLAS routine STPSV is called. If the matrix A is singular (A(j,j) = 0 for some j), then s is set to 0 and a non-trivial solution to A*x = 0 is returned.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| character, | intent(in) | :: | trans | |||
| character, | intent(in) | :: | diag | |||
| character, | intent(in) | :: | normin | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=sp), | intent(in) | :: | ap(*) | |||
| real(kind=sp), | intent(inout) | :: | x(*) | |||
| real(kind=sp), | intent(out) | :: | scale | |||
| real(kind=sp), | intent(inout) | :: | cnorm(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
ZLATPS solves one of the triangular systems A * x = sb, AT * x = sb, or AH * x = s*b, with scaling to prevent overflow, where A is an upper or lower triangular matrix stored in packed form. Here AT denotes the transpose of A, A*H denotes the conjugate transpose of A, x and b are n-element vectors, and s is a scaling factor, usually less than or equal to 1, chosen so that the components of x will be less than the overflow threshold. If the unscaled problem will not cause overflow, the Level 2 BLAS routine ZTPSV is called. If the matrix A is singular (A(j,j) = 0 for some j), then s is set to 0 and a non-trivial solution to Ax = 0 is returned.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| character, | intent(in) | :: | trans | |||
| character, | intent(in) | :: | diag | |||
| character, | intent(in) | :: | normin | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=dp), | intent(in) | :: | ap(*) | |||
| complex(kind=dp), | intent(inout) | :: | x(*) | |||
| real(kind=dp), | intent(out) | :: | scale | |||
| real(kind=dp), | intent(inout) | :: | cnorm(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
LATRD reduces NB rows and columns of a complex Hermitian matrix A to Hermitian tridiagonal form by a unitary similarity transformation Q**H * A * Q, and returns the matrices V and W which are needed to apply the transformation to the unreduced part of A. If UPLO = 'U', LATRD reduces the last NB rows and columns of a matrix, of which the upper triangle is supplied; if UPLO = 'L', LATRD reduces the first NB rows and columns of a matrix, of which the lower triangle is supplied. This is an auxiliary routine called by CHETRD.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nb | |||
| complex(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=sp), | intent(out) | :: | e(*) | |||
| complex(kind=sp), | intent(out) | :: | tau(*) | |||
| complex(kind=sp), | intent(out) | :: | w(ldw,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldw |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nb | |||
| real(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=dp), | intent(out) | :: | e(*) | |||
| real(kind=dp), | intent(out) | :: | tau(*) | |||
| real(kind=dp), | intent(out) | :: | w(ldw,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldw |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nb | |||
| real(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=sp), | intent(out) | :: | e(*) | |||
| real(kind=sp), | intent(out) | :: | tau(*) | |||
| real(kind=sp), | intent(out) | :: | w(ldw,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldw |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nb | |||
| complex(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=dp), | intent(out) | :: | e(*) | |||
| complex(kind=dp), | intent(out) | :: | tau(*) | |||
| complex(kind=dp), | intent(out) | :: | w(ldw,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldw |
CLATRD reduces NB rows and columns of a complex Hermitian matrix A to Hermitian tridiagonal form by a unitary similarity transformation Q**H * A * Q, and returns the matrices V and W which are needed to apply the transformation to the unreduced part of A. If UPLO = 'U', CLATRD reduces the last NB rows and columns of a matrix, of which the upper triangle is supplied; if UPLO = 'L', CLATRD reduces the first NB rows and columns of a matrix, of which the lower triangle is supplied. This is an auxiliary routine called by CHETRD.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nb | |||
| complex(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=sp), | intent(out) | :: | e(*) | |||
| complex(kind=sp), | intent(out) | :: | tau(*) | |||
| complex(kind=sp), | intent(out) | :: | w(ldw,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldw |
DLATRD reduces NB rows and columns of a real symmetric matrix A to symmetric tridiagonal form by an orthogonal similarity transformation Q**T * A * Q, and returns the matrices V and W which are needed to apply the transformation to the unreduced part of A. If UPLO = 'U', DLATRD reduces the last NB rows and columns of a matrix, of which the upper triangle is supplied; if UPLO = 'L', DLATRD reduces the first NB rows and columns of a matrix, of which the lower triangle is supplied. This is an auxiliary routine called by DSYTRD.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nb | |||
| real(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=dp), | intent(out) | :: | e(*) | |||
| real(kind=dp), | intent(out) | :: | tau(*) | |||
| real(kind=dp), | intent(out) | :: | w(ldw,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldw |
SLATRD reduces NB rows and columns of a real symmetric matrix A to symmetric tridiagonal form by an orthogonal similarity transformation Q**T * A * Q, and returns the matrices V and W which are needed to apply the transformation to the unreduced part of A. If UPLO = 'U', SLATRD reduces the last NB rows and columns of a matrix, of which the upper triangle is supplied; if UPLO = 'L', SLATRD reduces the first NB rows and columns of a matrix, of which the lower triangle is supplied. This is an auxiliary routine called by SSYTRD.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nb | |||
| real(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=sp), | intent(out) | :: | e(*) | |||
| real(kind=sp), | intent(out) | :: | tau(*) | |||
| real(kind=sp), | intent(out) | :: | w(ldw,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldw |
ZLATRD reduces NB rows and columns of a complex Hermitian matrix A to Hermitian tridiagonal form by a unitary similarity transformation Q**H * A * Q, and returns the matrices V and W which are needed to apply the transformation to the unreduced part of A. If UPLO = 'U', ZLATRD reduces the last NB rows and columns of a matrix, of which the upper triangle is supplied; if UPLO = 'L', ZLATRD reduces the first NB rows and columns of a matrix, of which the lower triangle is supplied. This is an auxiliary routine called by ZHETRD.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nb | |||
| complex(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=dp), | intent(out) | :: | e(*) | |||
| complex(kind=dp), | intent(out) | :: | tau(*) | |||
| complex(kind=dp), | intent(out) | :: | w(ldw,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldw |
LATRS solves one of the triangular systems A * x = sb, AT * x = sb, or AH * x = s*b, with scaling to prevent overflow. Here A is an upper or lower triangular matrix, AT denotes the transpose of A, A*H denotes the conjugate transpose of A, x and b are n-element vectors, and s is a scaling factor, usually less than or equal to 1, chosen so that the components of x will be less than the overflow threshold. If the unscaled problem will not cause overflow, the Level 2 BLAS routine CTRSV is called. If the matrix A is singular (A(j,j) = 0 for some j), then s is set to 0 and a non-trivial solution to Ax = 0 is returned.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| character, | intent(in) | :: | trans | |||
| character, | intent(in) | :: | diag | |||
| character, | intent(in) | :: | normin | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=sp), | intent(in) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=sp), | intent(inout) | :: | x(*) | |||
| real(kind=sp), | intent(out) | :: | scale | |||
| real(kind=sp), | intent(inout) | :: | cnorm(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| character, | intent(in) | :: | trans | |||
| character, | intent(in) | :: | diag | |||
| character, | intent(in) | :: | normin | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=dp), | intent(in) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=dp), | intent(inout) | :: | x(*) | |||
| real(kind=dp), | intent(out) | :: | scale | |||
| real(kind=dp), | intent(inout) | :: | cnorm(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| character, | intent(in) | :: | trans | |||
| character, | intent(in) | :: | diag | |||
| character, | intent(in) | :: | normin | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=sp), | intent(in) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=sp), | intent(inout) | :: | x(*) | |||
| real(kind=sp), | intent(out) | :: | scale | |||
| real(kind=sp), | intent(inout) | :: | cnorm(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| character, | intent(in) | :: | trans | |||
| character, | intent(in) | :: | diag | |||
| character, | intent(in) | :: | normin | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=dp), | intent(in) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=dp), | intent(inout) | :: | x(*) | |||
| real(kind=dp), | intent(out) | :: | scale | |||
| real(kind=dp), | intent(inout) | :: | cnorm(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
CLATRS solves one of the triangular systems A * x = sb, AT * x = sb, or AH * x = s*b, with scaling to prevent overflow. Here A is an upper or lower triangular matrix, AT denotes the transpose of A, A*H denotes the conjugate transpose of A, x and b are n-element vectors, and s is a scaling factor, usually less than or equal to 1, chosen so that the components of x will be less than the overflow threshold. If the unscaled problem will not cause overflow, the Level 2 BLAS routine CTRSV is called. If the matrix A is singular (A(j,j) = 0 for some j), then s is set to 0 and a non-trivial solution to Ax = 0 is returned.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| character, | intent(in) | :: | trans | |||
| character, | intent(in) | :: | diag | |||
| character, | intent(in) | :: | normin | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=sp), | intent(in) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=sp), | intent(inout) | :: | x(*) | |||
| real(kind=sp), | intent(out) | :: | scale | |||
| real(kind=sp), | intent(inout) | :: | cnorm(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
DLATRS solves one of the triangular systems A x = sb or AT x = sb with scaling to prevent overflow. Here A is an upper or lower triangular matrix, AT denotes the transpose of A, x and b are n-element vectors, and s is a scaling factor, usually less than or equal to 1, chosen so that the components of x will be less than the overflow threshold. If the unscaled problem will not cause overflow, the Level 2 BLAS routine DTRSV is called. If the matrix A is singular (A(j,j) = 0 for some j), then s is set to 0 and a non-trivial solution to A*x = 0 is returned.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| character, | intent(in) | :: | trans | |||
| character, | intent(in) | :: | diag | |||
| character, | intent(in) | :: | normin | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=dp), | intent(in) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=dp), | intent(inout) | :: | x(*) | |||
| real(kind=dp), | intent(out) | :: | scale | |||
| real(kind=dp), | intent(inout) | :: | cnorm(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
SLATRS solves one of the triangular systems A x = sb or ATx = sb with scaling to prevent overflow. Here A is an upper or lower triangular matrix, AT denotes the transpose of A, x and b are n-element vectors, and s is a scaling factor, usually less than or equal to 1, chosen so that the components of x will be less than the overflow threshold. If the unscaled problem will not cause overflow, the Level 2 BLAS routine STRSV is called. If the matrix A is singular (A(j,j) = 0 for some j), then s is set to 0 and a non-trivial solution to A*x = 0 is returned.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| character, | intent(in) | :: | trans | |||
| character, | intent(in) | :: | diag | |||
| character, | intent(in) | :: | normin | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=sp), | intent(in) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=sp), | intent(inout) | :: | x(*) | |||
| real(kind=sp), | intent(out) | :: | scale | |||
| real(kind=sp), | intent(inout) | :: | cnorm(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
ZLATRS solves one of the triangular systems A * x = sb, AT * x = sb, or AH * x = s*b, with scaling to prevent overflow. Here A is an upper or lower triangular matrix, AT denotes the transpose of A, A*H denotes the conjugate transpose of A, x and b are n-element vectors, and s is a scaling factor, usually less than or equal to 1, chosen so that the components of x will be less than the overflow threshold. If the unscaled problem will not cause overflow, the Level 2 BLAS routine ZTRSV is called. If the matrix A is singular (A(j,j) = 0 for some j), then s is set to 0 and a non-trivial solution to Ax = 0 is returned.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| character, | intent(in) | :: | trans | |||
| character, | intent(in) | :: | diag | |||
| character, | intent(in) | :: | normin | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=dp), | intent(in) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=dp), | intent(inout) | :: | x(*) | |||
| real(kind=dp), | intent(out) | :: | scale | |||
| real(kind=dp), | intent(inout) | :: | cnorm(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
LATRZ factors the M-by-(M+L) complex upper trapezoidal matrix [ A1 A2 ] = [ A(1:M,1:M) A(1:M,N-L+1:N) ] as ( R 0 ) * Z by means of unitary transformations, where Z is an (M+L)-by-(M+L) unitary matrix and, R and A1 are M-by-M upper triangular matrices.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | l | |||
| complex(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=sp), | intent(out) | :: | tau(*) | |||
| complex(kind=sp), | intent(out) | :: | work(*) |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | l | |||
| real(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=dp), | intent(out) | :: | tau(*) | |||
| real(kind=dp), | intent(out) | :: | work(*) |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | l | |||
| real(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=sp), | intent(out) | :: | tau(*) | |||
| real(kind=sp), | intent(out) | :: | work(*) |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | l | |||
| complex(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=dp), | intent(out) | :: | tau(*) | |||
| complex(kind=dp), | intent(out) | :: | work(*) |
CLATRZ factors the M-by-(M+L) complex upper trapezoidal matrix [ A1 A2 ] = [ A(1:M,1:M) A(1:M,N-L+1:N) ] as ( R 0 ) * Z by means of unitary transformations, where Z is an (M+L)-by-(M+L) unitary matrix and, R and A1 are M-by-M upper triangular matrices.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | l | |||
| complex(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=sp), | intent(out) | :: | tau(*) | |||
| complex(kind=sp), | intent(out) | :: | work(*) |
DLATRZ factors the M-by-(M+L) real upper trapezoidal matrix [ A1 A2 ] = [ A(1:M,1:M) A(1:M,N-L+1:N) ] as ( R 0 ) * Z, by means of orthogonal transformations. Z is an (M+L)-by-(M+L) orthogonal matrix and, R and A1 are M-by-M upper triangular matrices.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | l | |||
| real(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=dp), | intent(out) | :: | tau(*) | |||
| real(kind=dp), | intent(out) | :: | work(*) |
SLATRZ factors the M-by-(M+L) real upper trapezoidal matrix [ A1 A2 ] = [ A(1:M,1:M) A(1:M,N-L+1:N) ] as ( R 0 ) * Z, by means of orthogonal transformations. Z is an (M+L)-by-(M+L) orthogonal matrix and, R and A1 are M-by-M upper triangular matrices.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | l | |||
| real(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=sp), | intent(out) | :: | tau(*) | |||
| real(kind=sp), | intent(out) | :: | work(*) |
ZLATRZ factors the M-by-(M+L) complex upper trapezoidal matrix [ A1 A2 ] = [ A(1:M,1:M) A(1:M,N-L+1:N) ] as ( R 0 ) * Z by means of unitary transformations, where Z is an (M+L)-by-(M+L) unitary matrix and, R and A1 are M-by-M upper triangular matrices.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | l | |||
| complex(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=dp), | intent(out) | :: | tau(*) | |||
| complex(kind=dp), | intent(out) | :: | work(*) |
LATSQR computes a blocked Tall-Skinny QR factorization of a complex M-by-N matrix A for M >= N: A = Q * ( R ), ( 0 ) where: Q is a M-by-M orthogonal matrix, stored on exit in an implicit form in the elements below the diagonal of the array A and in the elements of the array T; R is an upper-triangular N-by-N matrix, stored on exit in the elements on and above the diagonal of the array A. 0 is a (M-N)-by-N zero matrix, and is not stored.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | mb | |||
| integer(kind=ilp), | intent(in) | :: | nb | |||
| complex(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=sp), | intent(out) | :: | t(ldt,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldt | |||
| complex(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | mb | |||
| integer(kind=ilp), | intent(in) | :: | nb | |||
| real(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=dp), | intent(out) | :: | t(ldt,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldt | |||
| real(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | mb | |||
| integer(kind=ilp), | intent(in) | :: | nb | |||
| real(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=sp), | intent(out) | :: | t(ldt,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldt | |||
| real(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | mb | |||
| integer(kind=ilp), | intent(in) | :: | nb | |||
| complex(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=dp), | intent(out) | :: | t(ldt,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldt | |||
| complex(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
CLATSQR computes a blocked Tall-Skinny QR factorization of a complex M-by-N matrix A for M >= N: A = Q * ( R ), ( 0 ) where: Q is a M-by-M orthogonal matrix, stored on exit in an implicit form in the elements below the diagonal of the array A and in the elements of the array T; R is an upper-triangular N-by-N matrix, stored on exit in the elements on and above the diagonal of the array A. 0 is a (M-N)-by-N zero matrix, and is not stored.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | mb | |||
| integer(kind=ilp), | intent(in) | :: | nb | |||
| complex(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=sp), | intent(out) | :: | t(ldt,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldt | |||
| complex(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
DLATSQR computes a blocked Tall-Skinny QR factorization of a real M-by-N matrix A for M >= N: A = Q * ( R ), ( 0 ) where: Q is a M-by-M orthogonal matrix, stored on exit in an implicit form in the elements below the diagonal of the array A and in the elements of the array T; R is an upper-triangular N-by-N matrix, stored on exit in the elements on and above the diagonal of the array A. 0 is a (M-N)-by-N zero matrix, and is not stored.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | mb | |||
| integer(kind=ilp), | intent(in) | :: | nb | |||
| real(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=dp), | intent(out) | :: | t(ldt,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldt | |||
| real(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
SLATSQR computes a blocked Tall-Skinny QR factorization of a real M-by-N matrix A for M >= N: A = Q * ( R ), ( 0 ) where: Q is a M-by-M orthogonal matrix, stored on exit in an implicit form in the elements below the diagonal of the array A and in the elements of the array T; R is an upper-triangular N-by-N matrix, stored on exit in the elements on and above the diagonal of the array A. 0 is a (M-N)-by-N zero matrix, and is not stored.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | mb | |||
| integer(kind=ilp), | intent(in) | :: | nb | |||
| real(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=sp), | intent(out) | :: | t(ldt,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldt | |||
| real(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
ZLATSQR computes a blocked Tall-Skinny QR factorization of a complex M-by-N matrix A for M >= N: A = Q * ( R ), ( 0 ) where: Q is a M-by-M orthogonal matrix, stored on exit in an implicit form in the elements below the diagonal of the array A and in the elements of the array T; R is an upper-triangular N-by-N matrix, stored on exit in the elements on and above the diagonal of the array A. 0 is a (M-N)-by-N zero matrix, and is not stored.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | mb | |||
| integer(kind=ilp), | intent(in) | :: | nb | |||
| complex(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=dp), | intent(out) | :: | t(ldt,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldt | |||
| complex(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
LAUNHR_COL_GETRFNP computes the modified LU factorization without pivoting of a complex general M-by-N matrix A. The factorization has the form: A - S = L * U, where: S is a m-by-n diagonal sign matrix with the diagonal D, so that D(i) = S(i,i), 1 <= i <= min(M,N). The diagonal D is constructed as D(i)=-SIGN(A(i,i)), where A(i,i) is the value after performing i-1 steps of Gaussian elimination. This means that the diagonal element at each step of "modified" Gaussian elimination is at least one in absolute value (so that division-by-zero not not possible during the division by the diagonal element); L is a M-by-N lower triangular matrix with unit diagonal elements (lower trapezoidal if M > N); and U is a M-by-N upper triangular matrix (upper trapezoidal if M < N). This routine is an auxiliary routine used in the Householder reconstruction routine CUNHR_COL. In CUNHR_COL, this routine is applied to an M-by-N matrix A with orthonormal columns, where each element is bounded by one in absolute value. With the choice of the matrix S above, one can show that the diagonal element at each step of Gaussian elimination is the largest (in absolute value) in the column on or below the diagonal, so that no pivoting is required for numerical stability [1]. For more details on the Householder reconstruction algorithm, including the modified LU factorization, see [1]. This is the blocked right-looking version of the algorithm, calling Level 3 BLAS to update the submatrix. To factorize a block, this routine calls the recursive routine LAUNHR_COL_GETRFNP2. [1] "Reconstructing Householder vectors from tall-skinny QR", G. Ballard, J. Demmel, L. Grigori, M. Jacquelin, H.D. Nguyen, E. Solomonik, J. Parallel Distrib. Comput., vol. 85, pp. 3-31, 2015.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=sp), | intent(out) | :: | d(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=dp), | intent(out) | :: | d(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
CLAUNHR_COL_GETRFNP computes the modified LU factorization without pivoting of a complex general M-by-N matrix A. The factorization has the form: A - S = L * U, where: S is a m-by-n diagonal sign matrix with the diagonal D, so that D(i) = S(i,i), 1 <= i <= min(M,N). The diagonal D is constructed as D(i)=-SIGN(A(i,i)), where A(i,i) is the value after performing i-1 steps of Gaussian elimination. This means that the diagonal element at each step of "modified" Gaussian elimination is at least one in absolute value (so that division-by-zero not not possible during the division by the diagonal element); L is a M-by-N lower triangular matrix with unit diagonal elements (lower trapezoidal if M > N); and U is a M-by-N upper triangular matrix (upper trapezoidal if M < N). This routine is an auxiliary routine used in the Householder reconstruction routine CUNHR_COL. In CUNHR_COL, this routine is applied to an M-by-N matrix A with orthonormal columns, where each element is bounded by one in absolute value. With the choice of the matrix S above, one can show that the diagonal element at each step of Gaussian elimination is the largest (in absolute value) in the column on or below the diagonal, so that no pivoting is required for numerical stability [1]. For more details on the Householder reconstruction algorithm, including the modified LU factorization, see [1]. This is the blocked right-looking version of the algorithm, calling Level 3 BLAS to update the submatrix. To factorize a block, this routine calls the recursive routine CLAUNHR_COL_GETRFNP2. [1] "Reconstructing Householder vectors from tall-skinny QR", G. Ballard, J. Demmel, L. Grigori, M. Jacquelin, H.D. Nguyen, E. Solomonik, J. Parallel Distrib. Comput., vol. 85, pp. 3-31, 2015.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=sp), | intent(out) | :: | d(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
ZLAUNHR_COL_GETRFNP computes the modified LU factorization without pivoting of a complex general M-by-N matrix A. The factorization has the form: A - S = L * U, where: S is a m-by-n diagonal sign matrix with the diagonal D, so that D(i) = S(i,i), 1 <= i <= min(M,N). The diagonal D is constructed as D(i)=-SIGN(A(i,i)), where A(i,i) is the value after performing i-1 steps of Gaussian elimination. This means that the diagonal element at each step of "modified" Gaussian elimination is at least one in absolute value (so that division-by-zero not not possible during the division by the diagonal element); L is a M-by-N lower triangular matrix with unit diagonal elements (lower trapezoidal if M > N); and U is a M-by-N upper triangular matrix (upper trapezoidal if M < N). This routine is an auxiliary routine used in the Householder reconstruction routine ZUNHR_COL. In ZUNHR_COL, this routine is applied to an M-by-N matrix A with orthonormal columns, where each element is bounded by one in absolute value. With the choice of the matrix S above, one can show that the diagonal element at each step of Gaussian elimination is the largest (in absolute value) in the column on or below the diagonal, so that no pivoting is required for numerical stability [1]. For more details on the Householder reconstruction algorithm, including the modified LU factorization, see [1]. This is the blocked right-looking version of the algorithm, calling Level 3 BLAS to update the submatrix. To factorize a block, this routine calls the recursive routine ZLAUNHR_COL_GETRFNP2. [1] "Reconstructing Householder vectors from tall-skinny QR", G. Ballard, J. Demmel, L. Grigori, M. Jacquelin, H.D. Nguyen, E. Solomonik, J. Parallel Distrib. Comput., vol. 85, pp. 3-31, 2015.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=dp), | intent(out) | :: | d(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
LAUNHR_COL_GETRFNP2 computes the modified LU factorization without pivoting of a complex general M-by-N matrix A. The factorization has the form: A - S = L * U, where: S is a m-by-n diagonal sign matrix with the diagonal D, so that D(i) = S(i,i), 1 <= i <= min(M,N). The diagonal D is constructed as D(i)=-SIGN(A(i,i)), where A(i,i) is the value after performing i-1 steps of Gaussian elimination. This means that the diagonal element at each step of "modified" Gaussian elimination is at least one in absolute value (so that division-by-zero not possible during the division by the diagonal element); L is a M-by-N lower triangular matrix with unit diagonal elements (lower trapezoidal if M > N); and U is a M-by-N upper triangular matrix (upper trapezoidal if M < N). This routine is an auxiliary routine used in the Householder reconstruction routine CUNHR_COL. In CUNHR_COL, this routine is applied to an M-by-N matrix A with orthonormal columns, where each element is bounded by one in absolute value. With the choice of the matrix S above, one can show that the diagonal element at each step of Gaussian elimination is the largest (in absolute value) in the column on or below the diagonal, so that no pivoting is required for numerical stability [1]. For more details on the Householder reconstruction algorithm, including the modified LU factorization, see [1]. This is the recursive version of the LU factorization algorithm. Denote A - S by B. The algorithm divides the matrix B into four submatrices: [ B11 | B12 ] where B11 is n1 by n1, B = [ -----|----- ] B21 is (m-n1) by n1, [ B21 | B22 ] B12 is n1 by n2, B22 is (m-n1) by n2, with n1 = min(m,n)/2, n2 = n-n1. The subroutine calls itself to factor B11, solves for B21, solves for B12, updates B22, then calls itself to factor B22. For more details on the recursive LU algorithm, see [2]. LAUNHR_COL_GETRFNP2 is called to factorize a block by the blocked routine CLAUNHR_COL_GETRFNP, which uses blocked code calling Level 3 BLAS to update the submatrix. However, LAUNHR_COL_GETRFNP2 is self-sufficient and can be used without CLAUNHR_COL_GETRFNP. [1] "Reconstructing Householder vectors from tall-skinny QR", G. Ballard, J. Demmel, L. Grigori, M. Jacquelin, H.D. Nguyen, E. Solomonik, J. Parallel Distrib. Comput., vol. 85, pp. 3-31, 2015. [2] "Recursion leads to automatic variable blocking for dense linear algebra algorithms", F. Gustavson, IBM J. of Res. and Dev., vol. 41, no. 6, pp. 737-755, 1997.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=sp), | intent(out) | :: | d(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=dp), | intent(out) | :: | d(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
CLAUNHR_COL_GETRFNP2 computes the modified LU factorization without pivoting of a complex general M-by-N matrix A. The factorization has the form: A - S = L * U, where: S is a m-by-n diagonal sign matrix with the diagonal D, so that D(i) = S(i,i), 1 <= i <= min(M,N). The diagonal D is constructed as D(i)=-SIGN(A(i,i)), where A(i,i) is the value after performing i-1 steps of Gaussian elimination. This means that the diagonal element at each step of "modified" Gaussian elimination is at least one in absolute value (so that division-by-zero not possible during the division by the diagonal element); L is a M-by-N lower triangular matrix with unit diagonal elements (lower trapezoidal if M > N); and U is a M-by-N upper triangular matrix (upper trapezoidal if M < N). This routine is an auxiliary routine used in the Householder reconstruction routine CUNHR_COL. In CUNHR_COL, this routine is applied to an M-by-N matrix A with orthonormal columns, where each element is bounded by one in absolute value. With the choice of the matrix S above, one can show that the diagonal element at each step of Gaussian elimination is the largest (in absolute value) in the column on or below the diagonal, so that no pivoting is required for numerical stability [1]. For more details on the Householder reconstruction algorithm, including the modified LU factorization, see [1]. This is the recursive version of the LU factorization algorithm. Denote A - S by B. The algorithm divides the matrix B into four submatrices: [ B11 | B12 ] where B11 is n1 by n1, B = [ -----|----- ] B21 is (m-n1) by n1, [ B21 | B22 ] B12 is n1 by n2, B22 is (m-n1) by n2, with n1 = min(m,n)/2, n2 = n-n1. The subroutine calls itself to factor B11, solves for B21, solves for B12, updates B22, then calls itself to factor B22. For more details on the recursive LU algorithm, see [2]. CLAUNHR_COL_GETRFNP2 is called to factorize a block by the blocked routine CLAUNHR_COL_GETRFNP, which uses blocked code calling Level 3 BLAS to update the submatrix. However, CLAUNHR_COL_GETRFNP2 is self-sufficient and can be used without CLAUNHR_COL_GETRFNP. [1] "Reconstructing Householder vectors from tall-skinny QR", G. Ballard, J. Demmel, L. Grigori, M. Jacquelin, H.D. Nguyen, E. Solomonik, J. Parallel Distrib. Comput., vol. 85, pp. 3-31, 2015. [2] "Recursion leads to automatic variable blocking for dense linear algebra algorithms", F. Gustavson, IBM J. of Res. and Dev., vol. 41, no. 6, pp. 737-755, 1997.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=sp), | intent(out) | :: | d(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
ZLAUNHR_COL_GETRFNP2 computes the modified LU factorization without pivoting of a complex general M-by-N matrix A. The factorization has the form: A - S = L * U, where: S is a m-by-n diagonal sign matrix with the diagonal D, so that D(i) = S(i,i), 1 <= i <= min(M,N). The diagonal D is constructed as D(i)=-SIGN(A(i,i)), where A(i,i) is the value after performing i-1 steps of Gaussian elimination. This means that the diagonal element at each step of "modified" Gaussian elimination is at least one in absolute value (so that division-by-zero not possible during the division by the diagonal element); L is a M-by-N lower triangular matrix with unit diagonal elements (lower trapezoidal if M > N); and U is a M-by-N upper triangular matrix (upper trapezoidal if M < N). This routine is an auxiliary routine used in the Householder reconstruction routine ZUNHR_COL. In ZUNHR_COL, this routine is applied to an M-by-N matrix A with orthonormal columns, where each element is bounded by one in absolute value. With the choice of the matrix S above, one can show that the diagonal element at each step of Gaussian elimination is the largest (in absolute value) in the column on or below the diagonal, so that no pivoting is required for numerical stability [1]. For more details on the Householder reconstruction algorithm, including the modified LU factorization, see [1]. This is the recursive version of the LU factorization algorithm. Denote A - S by B. The algorithm divides the matrix B into four submatrices: [ B11 | B12 ] where B11 is n1 by n1, B = [ -----|----- ] B21 is (m-n1) by n1, [ B21 | B22 ] B12 is n1 by n2, B22 is (m-n1) by n2, with n1 = min(m,n)/2, n2 = n-n1. The subroutine calls itself to factor B11, solves for B21, solves for B12, updates B22, then calls itself to factor B22. For more details on the recursive LU algorithm, see [2]. ZLAUNHR_COL_GETRFNP2 is called to factorize a block by the blocked routine ZLAUNHR_COL_GETRFNP, which uses blocked code calling Level 3 BLAS to update the submatrix. However, ZLAUNHR_COL_GETRFNP2 is self-sufficient and can be used without ZLAUNHR_COL_GETRFNP. [1] "Reconstructing Householder vectors from tall-skinny QR", G. Ballard, J. Demmel, L. Grigori, M. Jacquelin, H.D. Nguyen, E. Solomonik, J. Parallel Distrib. Comput., vol. 85, pp. 3-31, 2015. [2] "Recursion leads to automatic variable blocking for dense linear algebra algorithms", F. Gustavson, IBM J. of Res. and Dev., vol. 41, no. 6, pp. 737-755, 1997.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=dp), | intent(out) | :: | d(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
LAUUM computes the product U * UH or LH * L, where the triangular factor U or L is stored in the upper or lower triangular part of the array A. If UPLO = 'U' or 'u' then the upper triangle of the result is stored, overwriting the factor U in A. If UPLO = 'L' or 'l' then the lower triangle of the result is stored, overwriting the factor L in A. This is the blocked form of the algorithm, calling Level 3 BLAS.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| integer(kind=ilp), | intent(out) | :: | info |
CLAUUM computes the product U * UH or LH * L, where the triangular factor U or L is stored in the upper or lower triangular part of the array A. If UPLO = 'U' or 'u' then the upper triangle of the result is stored, overwriting the factor U in A. If UPLO = 'L' or 'l' then the lower triangle of the result is stored, overwriting the factor L in A. This is the blocked form of the algorithm, calling Level 3 BLAS.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| integer(kind=ilp), | intent(out) | :: | info |
DLAUUM computes the product U * UT or LT * L, where the triangular factor U or L is stored in the upper or lower triangular part of the array A. If UPLO = 'U' or 'u' then the upper triangle of the result is stored, overwriting the factor U in A. If UPLO = 'L' or 'l' then the lower triangle of the result is stored, overwriting the factor L in A. This is the blocked form of the algorithm, calling Level 3 BLAS.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| integer(kind=ilp), | intent(out) | :: | info |
SLAUUM computes the product U * UT or LT * L, where the triangular factor U or L is stored in the upper or lower triangular part of the array A. If UPLO = 'U' or 'u' then the upper triangle of the result is stored, overwriting the factor U in A. If UPLO = 'L' or 'l' then the lower triangle of the result is stored, overwriting the factor L in A. This is the blocked form of the algorithm, calling Level 3 BLAS.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| integer(kind=ilp), | intent(out) | :: | info |
ZLAUUM computes the product U * UH or LH * L, where the triangular factor U or L is stored in the upper or lower triangular part of the array A. If UPLO = 'U' or 'u' then the upper triangle of the result is stored, overwriting the factor U in A. If UPLO = 'L' or 'l' then the lower triangle of the result is stored, overwriting the factor L in A. This is the blocked form of the algorithm, calling Level 3 BLAS.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| integer(kind=ilp), | intent(out) | :: | info |
OPGTR generates a real orthogonal matrix Q which is defined as the product of n-1 elementary reflectors H(i) of order n, as returned by DSPTRD using packed storage: if UPLO = 'U', Q = H(n-1) . . . H(2) H(1), if UPLO = 'L', Q = H(1) H(2) . . . H(n-1).
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=dp), | intent(in) | :: | ap(*) | |||
| real(kind=dp), | intent(in) | :: | tau(*) | |||
| real(kind=dp), | intent(out) | :: | q(ldq,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldq | |||
| real(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=sp), | intent(in) | :: | ap(*) | |||
| real(kind=sp), | intent(in) | :: | tau(*) | |||
| real(kind=sp), | intent(out) | :: | q(ldq,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldq | |||
| real(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
DOPGTR generates a real orthogonal matrix Q which is defined as the product of n-1 elementary reflectors H(i) of order n, as returned by DSPTRD using packed storage: if UPLO = 'U', Q = H(n-1) . . . H(2) H(1), if UPLO = 'L', Q = H(1) H(2) . . . H(n-1).
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=dp), | intent(in) | :: | ap(*) | |||
| real(kind=dp), | intent(in) | :: | tau(*) | |||
| real(kind=dp), | intent(out) | :: | q(ldq,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldq | |||
| real(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
SOPGTR generates a real orthogonal matrix Q which is defined as the product of n-1 elementary reflectors H(i) of order n, as returned by SSPTRD using packed storage: if UPLO = 'U', Q = H(n-1) . . . H(2) H(1), if UPLO = 'L', Q = H(1) H(2) . . . H(n-1).
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=sp), | intent(in) | :: | ap(*) | |||
| real(kind=sp), | intent(in) | :: | tau(*) | |||
| real(kind=sp), | intent(out) | :: | q(ldq,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldq | |||
| real(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
OPMTR overwrites the general real M-by-N matrix C with SIDE = 'L' SIDE = 'R' TRANS = 'N': Q * C C * Q TRANS = 'T': QT * C C * QT where Q is a real orthogonal matrix of order nq, with nq = m if SIDE = 'L' and nq = n if SIDE = 'R'. Q is defined as the product of nq-1 elementary reflectors, as returned by DSPTRD using packed storage: if UPLO = 'U', Q = H(nq-1) . . . H(2) H(1); if UPLO = 'L', Q = H(1) H(2) . . . H(nq-1).
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | side | |||
| character, | intent(in) | :: | uplo | |||
| character, | intent(in) | :: | trans | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=dp), | intent(inout) | :: | ap(*) | |||
| real(kind=dp), | intent(in) | :: | tau(*) | |||
| real(kind=dp), | intent(inout) | :: | c(ldc,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldc | |||
| real(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | side | |||
| character, | intent(in) | :: | uplo | |||
| character, | intent(in) | :: | trans | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=sp), | intent(inout) | :: | ap(*) | |||
| real(kind=sp), | intent(in) | :: | tau(*) | |||
| real(kind=sp), | intent(inout) | :: | c(ldc,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldc | |||
| real(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
DOPMTR overwrites the general real M-by-N matrix C with SIDE = 'L' SIDE = 'R' TRANS = 'N': Q * C C * Q TRANS = 'T': QT * C C * QT where Q is a real orthogonal matrix of order nq, with nq = m if SIDE = 'L' and nq = n if SIDE = 'R'. Q is defined as the product of nq-1 elementary reflectors, as returned by DSPTRD using packed storage: if UPLO = 'U', Q = H(nq-1) . . . H(2) H(1); if UPLO = 'L', Q = H(1) H(2) . . . H(nq-1).
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | side | |||
| character, | intent(in) | :: | uplo | |||
| character, | intent(in) | :: | trans | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=dp), | intent(inout) | :: | ap(*) | |||
| real(kind=dp), | intent(in) | :: | tau(*) | |||
| real(kind=dp), | intent(inout) | :: | c(ldc,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldc | |||
| real(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
SOPMTR overwrites the general real M-by-N matrix C with SIDE = 'L' SIDE = 'R' TRANS = 'N': Q * C C * Q TRANS = 'T': QT * C C * QT where Q is a real orthogonal matrix of order nq, with nq = m if SIDE = 'L' and nq = n if SIDE = 'R'. Q is defined as the product of nq-1 elementary reflectors, as returned by SSPTRD using packed storage: if UPLO = 'U', Q = H(nq-1) . . . H(2) H(1); if UPLO = 'L', Q = H(1) H(2) . . . H(nq-1).
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | side | |||
| character, | intent(in) | :: | uplo | |||
| character, | intent(in) | :: | trans | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=sp), | intent(inout) | :: | ap(*) | |||
| real(kind=sp), | intent(in) | :: | tau(*) | |||
| real(kind=sp), | intent(inout) | :: | c(ldc,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldc | |||
| real(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
ORBDB simultaneously bidiagonalizes the blocks of an M-by-M partitioned orthogonal matrix X: [ B11 | B12 0 0 ] [ X11 | X12 ] [ P1 | ] [ 0 | 0 -I 0 ] [ Q1 | ]**T X = [-----------] = [---------] [----------------] [---------] . [ X21 | X22 ] [ | P2 ] [ B21 | B22 0 0 ] [ | Q2 ] [ 0 | 0 0 I ] X11 is P-by-Q. Q must be no larger than P, M-P, or M-Q. (If this is not the case, then X must be transposed and/or permuted. This can be done in constant time using the TRANS and SIGNS options. See DORCSD for details.) The orthogonal matrices P1, P2, Q1, and Q2 are P-by-P, (M-P)-by- (M-P), Q-by-Q, and (M-Q)-by-(M-Q), respectively. They are represented implicitly by Householder vectors. B11, B12, B21, and B22 are Q-by-Q bidiagonal matrices represented implicitly by angles THETA, PHI.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | trans | |||
| character, | intent(in) | :: | signs | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | p | |||
| integer(kind=ilp), | intent(in) | :: | q | |||
| real(kind=dp), | intent(inout) | :: | x11(ldx11,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldx11 | |||
| real(kind=dp), | intent(inout) | :: | x12(ldx12,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldx12 | |||
| real(kind=dp), | intent(inout) | :: | x21(ldx21,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldx21 | |||
| real(kind=dp), | intent(inout) | :: | x22(ldx22,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldx22 | |||
| real(kind=dp), | intent(out) | :: | theta(*) | |||
| real(kind=dp), | intent(out) | :: | phi(*) | |||
| real(kind=dp), | intent(out) | :: | taup1(*) | |||
| real(kind=dp), | intent(out) | :: | taup2(*) | |||
| real(kind=dp), | intent(out) | :: | tauq1(*) | |||
| real(kind=dp), | intent(out) | :: | tauq2(*) | |||
| real(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | trans | |||
| character, | intent(in) | :: | signs | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | p | |||
| integer(kind=ilp), | intent(in) | :: | q | |||
| real(kind=sp), | intent(inout) | :: | x11(ldx11,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldx11 | |||
| real(kind=sp), | intent(inout) | :: | x12(ldx12,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldx12 | |||
| real(kind=sp), | intent(inout) | :: | x21(ldx21,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldx21 | |||
| real(kind=sp), | intent(inout) | :: | x22(ldx22,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldx22 | |||
| real(kind=sp), | intent(out) | :: | theta(*) | |||
| real(kind=sp), | intent(out) | :: | phi(*) | |||
| real(kind=sp), | intent(out) | :: | taup1(*) | |||
| real(kind=sp), | intent(out) | :: | taup2(*) | |||
| real(kind=sp), | intent(out) | :: | tauq1(*) | |||
| real(kind=sp), | intent(out) | :: | tauq2(*) | |||
| real(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
DORBDB simultaneously bidiagonalizes the blocks of an M-by-M partitioned orthogonal matrix X: [ B11 | B12 0 0 ] [ X11 | X12 ] [ P1 | ] [ 0 | 0 -I 0 ] [ Q1 | ]**T X = [-----------] = [---------] [----------------] [---------] . [ X21 | X22 ] [ | P2 ] [ B21 | B22 0 0 ] [ | Q2 ] [ 0 | 0 0 I ] X11 is P-by-Q. Q must be no larger than P, M-P, or M-Q. (If this is not the case, then X must be transposed and/or permuted. This can be done in constant time using the TRANS and SIGNS options. See DORCSD for details.) The orthogonal matrices P1, P2, Q1, and Q2 are P-by-P, (M-P)-by- (M-P), Q-by-Q, and (M-Q)-by-(M-Q), respectively. They are represented implicitly by Householder vectors. B11, B12, B21, and B22 are Q-by-Q bidiagonal matrices represented implicitly by angles THETA, PHI.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | trans | |||
| character, | intent(in) | :: | signs | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | p | |||
| integer(kind=ilp), | intent(in) | :: | q | |||
| real(kind=dp), | intent(inout) | :: | x11(ldx11,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldx11 | |||
| real(kind=dp), | intent(inout) | :: | x12(ldx12,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldx12 | |||
| real(kind=dp), | intent(inout) | :: | x21(ldx21,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldx21 | |||
| real(kind=dp), | intent(inout) | :: | x22(ldx22,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldx22 | |||
| real(kind=dp), | intent(out) | :: | theta(*) | |||
| real(kind=dp), | intent(out) | :: | phi(*) | |||
| real(kind=dp), | intent(out) | :: | taup1(*) | |||
| real(kind=dp), | intent(out) | :: | taup2(*) | |||
| real(kind=dp), | intent(out) | :: | tauq1(*) | |||
| real(kind=dp), | intent(out) | :: | tauq2(*) | |||
| real(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
SORBDB simultaneously bidiagonalizes the blocks of an M-by-M partitioned orthogonal matrix X: [ B11 | B12 0 0 ] [ X11 | X12 ] [ P1 | ] [ 0 | 0 -I 0 ] [ Q1 | ]**T X = [-----------] = [---------] [----------------] [---------] . [ X21 | X22 ] [ | P2 ] [ B21 | B22 0 0 ] [ | Q2 ] [ 0 | 0 0 I ] X11 is P-by-Q. Q must be no larger than P, M-P, or M-Q. (If this is not the case, then X must be transposed and/or permuted. This can be done in constant time using the TRANS and SIGNS options. See SORCSD for details.) The orthogonal matrices P1, P2, Q1, and Q2 are P-by-P, (M-P)-by- (M-P), Q-by-Q, and (M-Q)-by-(M-Q), respectively. They are represented implicitly by Householder vectors. B11, B12, B21, and B22 are Q-by-Q bidiagonal matrices represented implicitly by angles THETA, PHI.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | trans | |||
| character, | intent(in) | :: | signs | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | p | |||
| integer(kind=ilp), | intent(in) | :: | q | |||
| real(kind=sp), | intent(inout) | :: | x11(ldx11,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldx11 | |||
| real(kind=sp), | intent(inout) | :: | x12(ldx12,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldx12 | |||
| real(kind=sp), | intent(inout) | :: | x21(ldx21,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldx21 | |||
| real(kind=sp), | intent(inout) | :: | x22(ldx22,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldx22 | |||
| real(kind=sp), | intent(out) | :: | theta(*) | |||
| real(kind=sp), | intent(out) | :: | phi(*) | |||
| real(kind=sp), | intent(out) | :: | taup1(*) | |||
| real(kind=sp), | intent(out) | :: | taup2(*) | |||
| real(kind=sp), | intent(out) | :: | tauq1(*) | |||
| real(kind=sp), | intent(out) | :: | tauq2(*) | |||
| real(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
ORBDB1 simultaneously bidiagonalizes the blocks of a tall and skinny matrix X with orthonomal columns: [ B11 ] [ X11 ] [ P1 | ] [ 0 ] [-----] = [---------] [-----] Q1**T . [ X21 ] [ | P2 ] [ B21 ] [ 0 ] X11 is P-by-Q, and X21 is (M-P)-by-Q. Q must be no larger than P, M-P, or M-Q. Routines DORBDB2, DORBDB3, and DORBDB4 handle cases in which Q is not the minimum dimension. The orthogonal matrices P1, P2, and Q1 are P-by-P, (M-P)-by-(M-P), and (M-Q)-by-(M-Q), respectively. They are represented implicitly by Householder vectors. B11 and B12 are Q-by-Q bidiagonal matrices represented implicitly by angles THETA, PHI.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | p | |||
| integer(kind=ilp), | intent(in) | :: | q | |||
| real(kind=dp), | intent(inout) | :: | x11(ldx11,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldx11 | |||
| real(kind=dp), | intent(inout) | :: | x21(ldx21,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldx21 | |||
| real(kind=dp), | intent(out) | :: | theta(*) | |||
| real(kind=dp), | intent(out) | :: | phi(*) | |||
| real(kind=dp), | intent(out) | :: | taup1(*) | |||
| real(kind=dp), | intent(out) | :: | taup2(*) | |||
| real(kind=dp), | intent(out) | :: | tauq1(*) | |||
| real(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | p | |||
| integer(kind=ilp), | intent(in) | :: | q | |||
| real(kind=sp), | intent(inout) | :: | x11(ldx11,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldx11 | |||
| real(kind=sp), | intent(inout) | :: | x21(ldx21,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldx21 | |||
| real(kind=sp), | intent(out) | :: | theta(*) | |||
| real(kind=sp), | intent(out) | :: | phi(*) | |||
| real(kind=sp), | intent(out) | :: | taup1(*) | |||
| real(kind=sp), | intent(out) | :: | taup2(*) | |||
| real(kind=sp), | intent(out) | :: | tauq1(*) | |||
| real(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
DORBDB1 simultaneously bidiagonalizes the blocks of a tall and skinny matrix X with orthonomal columns: [ B11 ] [ X11 ] [ P1 | ] [ 0 ] [-----] = [---------] [-----] Q1**T . [ X21 ] [ | P2 ] [ B21 ] [ 0 ] X11 is P-by-Q, and X21 is (M-P)-by-Q. Q must be no larger than P, M-P, or M-Q. Routines DORBDB2, DORBDB3, and DORBDB4 handle cases in which Q is not the minimum dimension. The orthogonal matrices P1, P2, and Q1 are P-by-P, (M-P)-by-(M-P), and (M-Q)-by-(M-Q), respectively. They are represented implicitly by Householder vectors. B11 and B12 are Q-by-Q bidiagonal matrices represented implicitly by angles THETA, PHI.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | p | |||
| integer(kind=ilp), | intent(in) | :: | q | |||
| real(kind=dp), | intent(inout) | :: | x11(ldx11,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldx11 | |||
| real(kind=dp), | intent(inout) | :: | x21(ldx21,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldx21 | |||
| real(kind=dp), | intent(out) | :: | theta(*) | |||
| real(kind=dp), | intent(out) | :: | phi(*) | |||
| real(kind=dp), | intent(out) | :: | taup1(*) | |||
| real(kind=dp), | intent(out) | :: | taup2(*) | |||
| real(kind=dp), | intent(out) | :: | tauq1(*) | |||
| real(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
SORBDB1 simultaneously bidiagonalizes the blocks of a tall and skinny matrix X with orthonomal columns: [ B11 ] [ X11 ] [ P1 | ] [ 0 ] [-----] = [---------] [-----] Q1**T . [ X21 ] [ | P2 ] [ B21 ] [ 0 ] X11 is P-by-Q, and X21 is (M-P)-by-Q. Q must be no larger than P, M-P, or M-Q. Routines SORBDB2, SORBDB3, and SORBDB4 handle cases in which Q is not the minimum dimension. The orthogonal matrices P1, P2, and Q1 are P-by-P, (M-P)-by-(M-P), and (M-Q)-by-(M-Q), respectively. They are represented implicitly by Householder vectors. B11 and B12 are Q-by-Q bidiagonal matrices represented implicitly by angles THETA, PHI.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | p | |||
| integer(kind=ilp), | intent(in) | :: | q | |||
| real(kind=sp), | intent(inout) | :: | x11(ldx11,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldx11 | |||
| real(kind=sp), | intent(inout) | :: | x21(ldx21,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldx21 | |||
| real(kind=sp), | intent(out) | :: | theta(*) | |||
| real(kind=sp), | intent(out) | :: | phi(*) | |||
| real(kind=sp), | intent(out) | :: | taup1(*) | |||
| real(kind=sp), | intent(out) | :: | taup2(*) | |||
| real(kind=sp), | intent(out) | :: | tauq1(*) | |||
| real(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
ORBDB2 simultaneously bidiagonalizes the blocks of a tall and skinny matrix X with orthonomal columns: [ B11 ] [ X11 ] [ P1 | ] [ 0 ] [-----] = [---------] [-----] Q1**T . [ X21 ] [ | P2 ] [ B21 ] [ 0 ] X11 is P-by-Q, and X21 is (M-P)-by-Q. P must be no larger than M-P, Q, or M-Q. Routines DORBDB1, DORBDB3, and DORBDB4 handle cases in which P is not the minimum dimension. The orthogonal matrices P1, P2, and Q1 are P-by-P, (M-P)-by-(M-P), and (M-Q)-by-(M-Q), respectively. They are represented implicitly by Householder vectors. B11 and B12 are P-by-P bidiagonal matrices represented implicitly by angles THETA, PHI.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | p | |||
| integer(kind=ilp), | intent(in) | :: | q | |||
| real(kind=dp), | intent(inout) | :: | x11(ldx11,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldx11 | |||
| real(kind=dp), | intent(inout) | :: | x21(ldx21,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldx21 | |||
| real(kind=dp), | intent(out) | :: | theta(*) | |||
| real(kind=dp), | intent(out) | :: | phi(*) | |||
| real(kind=dp), | intent(out) | :: | taup1(*) | |||
| real(kind=dp), | intent(out) | :: | taup2(*) | |||
| real(kind=dp), | intent(out) | :: | tauq1(*) | |||
| real(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | p | |||
| integer(kind=ilp), | intent(in) | :: | q | |||
| real(kind=sp), | intent(inout) | :: | x11(ldx11,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldx11 | |||
| real(kind=sp), | intent(inout) | :: | x21(ldx21,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldx21 | |||
| real(kind=sp), | intent(out) | :: | theta(*) | |||
| real(kind=sp), | intent(out) | :: | phi(*) | |||
| real(kind=sp), | intent(out) | :: | taup1(*) | |||
| real(kind=sp), | intent(out) | :: | taup2(*) | |||
| real(kind=sp), | intent(out) | :: | tauq1(*) | |||
| real(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
DORBDB2 simultaneously bidiagonalizes the blocks of a tall and skinny matrix X with orthonomal columns: [ B11 ] [ X11 ] [ P1 | ] [ 0 ] [-----] = [---------] [-----] Q1**T . [ X21 ] [ | P2 ] [ B21 ] [ 0 ] X11 is P-by-Q, and X21 is (M-P)-by-Q. P must be no larger than M-P, Q, or M-Q. Routines DORBDB1, DORBDB3, and DORBDB4 handle cases in which P is not the minimum dimension. The orthogonal matrices P1, P2, and Q1 are P-by-P, (M-P)-by-(M-P), and (M-Q)-by-(M-Q), respectively. They are represented implicitly by Householder vectors. B11 and B12 are P-by-P bidiagonal matrices represented implicitly by angles THETA, PHI.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | p | |||
| integer(kind=ilp), | intent(in) | :: | q | |||
| real(kind=dp), | intent(inout) | :: | x11(ldx11,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldx11 | |||
| real(kind=dp), | intent(inout) | :: | x21(ldx21,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldx21 | |||
| real(kind=dp), | intent(out) | :: | theta(*) | |||
| real(kind=dp), | intent(out) | :: | phi(*) | |||
| real(kind=dp), | intent(out) | :: | taup1(*) | |||
| real(kind=dp), | intent(out) | :: | taup2(*) | |||
| real(kind=dp), | intent(out) | :: | tauq1(*) | |||
| real(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
SORBDB2 simultaneously bidiagonalizes the blocks of a tall and skinny matrix X with orthonomal columns: [ B11 ] [ X11 ] [ P1 | ] [ 0 ] [-----] = [---------] [-----] Q1**T . [ X21 ] [ | P2 ] [ B21 ] [ 0 ] X11 is P-by-Q, and X21 is (M-P)-by-Q. P must be no larger than M-P, Q, or M-Q. Routines SORBDB1, SORBDB3, and SORBDB4 handle cases in which P is not the minimum dimension. The orthogonal matrices P1, P2, and Q1 are P-by-P, (M-P)-by-(M-P), and (M-Q)-by-(M-Q), respectively. They are represented implicitly by Householder vectors. B11 and B12 are P-by-P bidiagonal matrices represented implicitly by angles THETA, PHI.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | p | |||
| integer(kind=ilp), | intent(in) | :: | q | |||
| real(kind=sp), | intent(inout) | :: | x11(ldx11,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldx11 | |||
| real(kind=sp), | intent(inout) | :: | x21(ldx21,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldx21 | |||
| real(kind=sp), | intent(out) | :: | theta(*) | |||
| real(kind=sp), | intent(out) | :: | phi(*) | |||
| real(kind=sp), | intent(out) | :: | taup1(*) | |||
| real(kind=sp), | intent(out) | :: | taup2(*) | |||
| real(kind=sp), | intent(out) | :: | tauq1(*) | |||
| real(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
ORBDB3 simultaneously bidiagonalizes the blocks of a tall and skinny matrix X with orthonomal columns: [ B11 ] [ X11 ] [ P1 | ] [ 0 ] [-----] = [---------] [-----] Q1**T . [ X21 ] [ | P2 ] [ B21 ] [ 0 ] X11 is P-by-Q, and X21 is (M-P)-by-Q. M-P must be no larger than P, Q, or M-Q. Routines DORBDB1, DORBDB2, and DORBDB4 handle cases in which M-P is not the minimum dimension. The orthogonal matrices P1, P2, and Q1 are P-by-P, (M-P)-by-(M-P), and (M-Q)-by-(M-Q), respectively. They are represented implicitly by Householder vectors. B11 and B12 are (M-P)-by-(M-P) bidiagonal matrices represented implicitly by angles THETA, PHI.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | p | |||
| integer(kind=ilp), | intent(in) | :: | q | |||
| real(kind=dp), | intent(inout) | :: | x11(ldx11,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldx11 | |||
| real(kind=dp), | intent(inout) | :: | x21(ldx21,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldx21 | |||
| real(kind=dp), | intent(out) | :: | theta(*) | |||
| real(kind=dp), | intent(out) | :: | phi(*) | |||
| real(kind=dp), | intent(out) | :: | taup1(*) | |||
| real(kind=dp), | intent(out) | :: | taup2(*) | |||
| real(kind=dp), | intent(out) | :: | tauq1(*) | |||
| real(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | p | |||
| integer(kind=ilp), | intent(in) | :: | q | |||
| real(kind=sp), | intent(inout) | :: | x11(ldx11,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldx11 | |||
| real(kind=sp), | intent(inout) | :: | x21(ldx21,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldx21 | |||
| real(kind=sp), | intent(out) | :: | theta(*) | |||
| real(kind=sp), | intent(out) | :: | phi(*) | |||
| real(kind=sp), | intent(out) | :: | taup1(*) | |||
| real(kind=sp), | intent(out) | :: | taup2(*) | |||
| real(kind=sp), | intent(out) | :: | tauq1(*) | |||
| real(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
DORBDB3 simultaneously bidiagonalizes the blocks of a tall and skinny matrix X with orthonomal columns: [ B11 ] [ X11 ] [ P1 | ] [ 0 ] [-----] = [---------] [-----] Q1**T . [ X21 ] [ | P2 ] [ B21 ] [ 0 ] X11 is P-by-Q, and X21 is (M-P)-by-Q. M-P must be no larger than P, Q, or M-Q. Routines DORBDB1, DORBDB2, and DORBDB4 handle cases in which M-P is not the minimum dimension. The orthogonal matrices P1, P2, and Q1 are P-by-P, (M-P)-by-(M-P), and (M-Q)-by-(M-Q), respectively. They are represented implicitly by Householder vectors. B11 and B12 are (M-P)-by-(M-P) bidiagonal matrices represented implicitly by angles THETA, PHI.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | p | |||
| integer(kind=ilp), | intent(in) | :: | q | |||
| real(kind=dp), | intent(inout) | :: | x11(ldx11,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldx11 | |||
| real(kind=dp), | intent(inout) | :: | x21(ldx21,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldx21 | |||
| real(kind=dp), | intent(out) | :: | theta(*) | |||
| real(kind=dp), | intent(out) | :: | phi(*) | |||
| real(kind=dp), | intent(out) | :: | taup1(*) | |||
| real(kind=dp), | intent(out) | :: | taup2(*) | |||
| real(kind=dp), | intent(out) | :: | tauq1(*) | |||
| real(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
SORBDB3 simultaneously bidiagonalizes the blocks of a tall and skinny matrix X with orthonomal columns: [ B11 ] [ X11 ] [ P1 | ] [ 0 ] [-----] = [---------] [-----] Q1**T . [ X21 ] [ | P2 ] [ B21 ] [ 0 ] X11 is P-by-Q, and X21 is (M-P)-by-Q. M-P must be no larger than P, Q, or M-Q. Routines SORBDB1, SORBDB2, and SORBDB4 handle cases in which M-P is not the minimum dimension. The orthogonal matrices P1, P2, and Q1 are P-by-P, (M-P)-by-(M-P), and (M-Q)-by-(M-Q), respectively. They are represented implicitly by Householder vectors. B11 and B12 are (M-P)-by-(M-P) bidiagonal matrices represented implicitly by angles THETA, PHI.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | p | |||
| integer(kind=ilp), | intent(in) | :: | q | |||
| real(kind=sp), | intent(inout) | :: | x11(ldx11,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldx11 | |||
| real(kind=sp), | intent(inout) | :: | x21(ldx21,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldx21 | |||
| real(kind=sp), | intent(out) | :: | theta(*) | |||
| real(kind=sp), | intent(out) | :: | phi(*) | |||
| real(kind=sp), | intent(out) | :: | taup1(*) | |||
| real(kind=sp), | intent(out) | :: | taup2(*) | |||
| real(kind=sp), | intent(out) | :: | tauq1(*) | |||
| real(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
ORBDB4 simultaneously bidiagonalizes the blocks of a tall and skinny matrix X with orthonomal columns: [ B11 ] [ X11 ] [ P1 | ] [ 0 ] [-----] = [---------] [-----] Q1**T . [ X21 ] [ | P2 ] [ B21 ] [ 0 ] X11 is P-by-Q, and X21 is (M-P)-by-Q. M-Q must be no larger than P, M-P, or Q. Routines DORBDB1, DORBDB2, and DORBDB3 handle cases in which M-Q is not the minimum dimension. The orthogonal matrices P1, P2, and Q1 are P-by-P, (M-P)-by-(M-P), and (M-Q)-by-(M-Q), respectively. They are represented implicitly by Householder vectors. B11 and B12 are (M-Q)-by-(M-Q) bidiagonal matrices represented implicitly by angles THETA, PHI.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | p | |||
| integer(kind=ilp), | intent(in) | :: | q | |||
| real(kind=dp), | intent(inout) | :: | x11(ldx11,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldx11 | |||
| real(kind=dp), | intent(inout) | :: | x21(ldx21,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldx21 | |||
| real(kind=dp), | intent(out) | :: | theta(*) | |||
| real(kind=dp), | intent(out) | :: | phi(*) | |||
| real(kind=dp), | intent(out) | :: | taup1(*) | |||
| real(kind=dp), | intent(out) | :: | taup2(*) | |||
| real(kind=dp), | intent(out) | :: | tauq1(*) | |||
| real(kind=dp), | intent(out) | :: | phantom(*) | |||
| real(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | p | |||
| integer(kind=ilp), | intent(in) | :: | q | |||
| real(kind=sp), | intent(inout) | :: | x11(ldx11,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldx11 | |||
| real(kind=sp), | intent(inout) | :: | x21(ldx21,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldx21 | |||
| real(kind=sp), | intent(out) | :: | theta(*) | |||
| real(kind=sp), | intent(out) | :: | phi(*) | |||
| real(kind=sp), | intent(out) | :: | taup1(*) | |||
| real(kind=sp), | intent(out) | :: | taup2(*) | |||
| real(kind=sp), | intent(out) | :: | tauq1(*) | |||
| real(kind=sp), | intent(out) | :: | phantom(*) | |||
| real(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
DORBDB4 simultaneously bidiagonalizes the blocks of a tall and skinny matrix X with orthonomal columns: [ B11 ] [ X11 ] [ P1 | ] [ 0 ] [-----] = [---------] [-----] Q1**T . [ X21 ] [ | P2 ] [ B21 ] [ 0 ] X11 is P-by-Q, and X21 is (M-P)-by-Q. M-Q must be no larger than P, M-P, or Q. Routines DORBDB1, DORBDB2, and DORBDB3 handle cases in which M-Q is not the minimum dimension. The orthogonal matrices P1, P2, and Q1 are P-by-P, (M-P)-by-(M-P), and (M-Q)-by-(M-Q), respectively. They are represented implicitly by Householder vectors. B11 and B12 are (M-Q)-by-(M-Q) bidiagonal matrices represented implicitly by angles THETA, PHI.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | p | |||
| integer(kind=ilp), | intent(in) | :: | q | |||
| real(kind=dp), | intent(inout) | :: | x11(ldx11,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldx11 | |||
| real(kind=dp), | intent(inout) | :: | x21(ldx21,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldx21 | |||
| real(kind=dp), | intent(out) | :: | theta(*) | |||
| real(kind=dp), | intent(out) | :: | phi(*) | |||
| real(kind=dp), | intent(out) | :: | taup1(*) | |||
| real(kind=dp), | intent(out) | :: | taup2(*) | |||
| real(kind=dp), | intent(out) | :: | tauq1(*) | |||
| real(kind=dp), | intent(out) | :: | phantom(*) | |||
| real(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
SORBDB4 simultaneously bidiagonalizes the blocks of a tall and skinny matrix X with orthonomal columns: [ B11 ] [ X11 ] [ P1 | ] [ 0 ] [-----] = [---------] [-----] Q1**T . [ X21 ] [ | P2 ] [ B21 ] [ 0 ] X11 is P-by-Q, and X21 is (M-P)-by-Q. M-Q must be no larger than P, M-P, or Q. Routines SORBDB1, SORBDB2, and SORBDB3 handle cases in which M-Q is not the minimum dimension. The orthogonal matrices P1, P2, and Q1 are P-by-P, (M-P)-by-(M-P), and (M-Q)-by-(M-Q), respectively. They are represented implicitly by Householder vectors. B11 and B12 are (M-Q)-by-(M-Q) bidiagonal matrices represented implicitly by angles THETA, PHI.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | p | |||
| integer(kind=ilp), | intent(in) | :: | q | |||
| real(kind=sp), | intent(inout) | :: | x11(ldx11,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldx11 | |||
| real(kind=sp), | intent(inout) | :: | x21(ldx21,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldx21 | |||
| real(kind=sp), | intent(out) | :: | theta(*) | |||
| real(kind=sp), | intent(out) | :: | phi(*) | |||
| real(kind=sp), | intent(out) | :: | taup1(*) | |||
| real(kind=sp), | intent(out) | :: | taup2(*) | |||
| real(kind=sp), | intent(out) | :: | tauq1(*) | |||
| real(kind=sp), | intent(out) | :: | phantom(*) | |||
| real(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
ORBDB5 orthogonalizes the column vector X = [ X1 ] [ X2 ] with respect to the columns of Q = [ Q1 ] . [ Q2 ] The columns of Q must be orthonormal. If the projection is zero according to Kahan's "twice is enough" criterion, then some other vector from the orthogonal complement is returned. This vector is chosen in an arbitrary but deterministic way.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m1 | |||
| integer(kind=ilp), | intent(in) | :: | m2 | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=dp), | intent(inout) | :: | x1(*) | |||
| integer(kind=ilp), | intent(in) | :: | incx1 | |||
| real(kind=dp), | intent(inout) | :: | x2(*) | |||
| integer(kind=ilp), | intent(in) | :: | incx2 | |||
| real(kind=dp), | intent(in) | :: | q1(ldq1,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldq1 | |||
| real(kind=dp), | intent(in) | :: | q2(ldq2,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldq2 | |||
| real(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m1 | |||
| integer(kind=ilp), | intent(in) | :: | m2 | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=sp), | intent(inout) | :: | x1(*) | |||
| integer(kind=ilp), | intent(in) | :: | incx1 | |||
| real(kind=sp), | intent(inout) | :: | x2(*) | |||
| integer(kind=ilp), | intent(in) | :: | incx2 | |||
| real(kind=sp), | intent(in) | :: | q1(ldq1,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldq1 | |||
| real(kind=sp), | intent(in) | :: | q2(ldq2,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldq2 | |||
| real(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
DORBDB5 orthogonalizes the column vector X = [ X1 ] [ X2 ] with respect to the columns of Q = [ Q1 ] . [ Q2 ] The columns of Q must be orthonormal. If the projection is zero according to Kahan's "twice is enough" criterion, then some other vector from the orthogonal complement is returned. This vector is chosen in an arbitrary but deterministic way.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m1 | |||
| integer(kind=ilp), | intent(in) | :: | m2 | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=dp), | intent(inout) | :: | x1(*) | |||
| integer(kind=ilp), | intent(in) | :: | incx1 | |||
| real(kind=dp), | intent(inout) | :: | x2(*) | |||
| integer(kind=ilp), | intent(in) | :: | incx2 | |||
| real(kind=dp), | intent(in) | :: | q1(ldq1,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldq1 | |||
| real(kind=dp), | intent(in) | :: | q2(ldq2,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldq2 | |||
| real(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
SORBDB5 orthogonalizes the column vector X = [ X1 ] [ X2 ] with respect to the columns of Q = [ Q1 ] . [ Q2 ] The columns of Q must be orthonormal. If the projection is zero according to Kahan's "twice is enough" criterion, then some other vector from the orthogonal complement is returned. This vector is chosen in an arbitrary but deterministic way.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m1 | |||
| integer(kind=ilp), | intent(in) | :: | m2 | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=sp), | intent(inout) | :: | x1(*) | |||
| integer(kind=ilp), | intent(in) | :: | incx1 | |||
| real(kind=sp), | intent(inout) | :: | x2(*) | |||
| integer(kind=ilp), | intent(in) | :: | incx2 | |||
| real(kind=sp), | intent(in) | :: | q1(ldq1,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldq1 | |||
| real(kind=sp), | intent(in) | :: | q2(ldq2,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldq2 | |||
| real(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
ORBDB6 orthogonalizes the column vector X = [ X1 ] [ X2 ] with respect to the columns of Q = [ Q1 ] . [ Q2 ] The columns of Q must be orthonormal. If the projection is zero according to Kahan's "twice is enough" criterion, then the zero vector is returned.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m1 | |||
| integer(kind=ilp), | intent(in) | :: | m2 | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=dp), | intent(inout) | :: | x1(*) | |||
| integer(kind=ilp), | intent(in) | :: | incx1 | |||
| real(kind=dp), | intent(inout) | :: | x2(*) | |||
| integer(kind=ilp), | intent(in) | :: | incx2 | |||
| real(kind=dp), | intent(in) | :: | q1(ldq1,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldq1 | |||
| real(kind=dp), | intent(in) | :: | q2(ldq2,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldq2 | |||
| real(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m1 | |||
| integer(kind=ilp), | intent(in) | :: | m2 | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=sp), | intent(inout) | :: | x1(*) | |||
| integer(kind=ilp), | intent(in) | :: | incx1 | |||
| real(kind=sp), | intent(inout) | :: | x2(*) | |||
| integer(kind=ilp), | intent(in) | :: | incx2 | |||
| real(kind=sp), | intent(in) | :: | q1(ldq1,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldq1 | |||
| real(kind=sp), | intent(in) | :: | q2(ldq2,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldq2 | |||
| real(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
DORBDB6 orthogonalizes the column vector X = [ X1 ] [ X2 ] with respect to the columns of Q = [ Q1 ] . [ Q2 ] The columns of Q must be orthonormal. If the projection is zero according to Kahan's "twice is enough" criterion, then the zero vector is returned.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m1 | |||
| integer(kind=ilp), | intent(in) | :: | m2 | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=dp), | intent(inout) | :: | x1(*) | |||
| integer(kind=ilp), | intent(in) | :: | incx1 | |||
| real(kind=dp), | intent(inout) | :: | x2(*) | |||
| integer(kind=ilp), | intent(in) | :: | incx2 | |||
| real(kind=dp), | intent(in) | :: | q1(ldq1,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldq1 | |||
| real(kind=dp), | intent(in) | :: | q2(ldq2,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldq2 | |||
| real(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
SORBDB6 orthogonalizes the column vector X = [ X1 ] [ X2 ] with respect to the columns of Q = [ Q1 ] . [ Q2 ] The columns of Q must be orthonormal. If the projection is zero according to Kahan's "twice is enough" criterion, then the zero vector is returned.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m1 | |||
| integer(kind=ilp), | intent(in) | :: | m2 | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=sp), | intent(inout) | :: | x1(*) | |||
| integer(kind=ilp), | intent(in) | :: | incx1 | |||
| real(kind=sp), | intent(inout) | :: | x2(*) | |||
| integer(kind=ilp), | intent(in) | :: | incx2 | |||
| real(kind=sp), | intent(in) | :: | q1(ldq1,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldq1 | |||
| real(kind=sp), | intent(in) | :: | q2(ldq2,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldq2 | |||
| real(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
ORCSD computes the CS decomposition of an M-by-M partitioned orthogonal matrix X: [ I 0 0 | 0 0 0 ] [ 0 C 0 | 0 -S 0 ] [ X11 | X12 ] [ U1 | ] [ 0 0 0 | 0 0 -I ] [ V1 | ]**T X = [-----------] = [---------] [---------------------] [---------] . [ X21 | X22 ] [ | U2 ] [ 0 0 0 | I 0 0 ] [ | V2 ] [ 0 S 0 | 0 C 0 ] [ 0 0 I | 0 0 0 ] X11 is P-by-Q. The orthogonal matrices U1, U2, V1, and V2 are P-by-P, (M-P)-by-(M-P), Q-by-Q, and (M-Q)-by-(M-Q), respectively. C and S are R-by-R nonnegative diagonal matrices satisfying C^2 + S^2 = I, in which R = MIN(P,M-P,Q,M-Q).
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | jobu1 | |||
| character, | intent(in) | :: | jobu2 | |||
| character, | intent(in) | :: | jobv1t | |||
| character, | intent(in) | :: | jobv2t | |||
| character, | intent(in) | :: | trans | |||
| character, | intent(in) | :: | signs | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | p | |||
| integer(kind=ilp), | intent(in) | :: | q | |||
| real(kind=dp), | intent(inout) | :: | x11(ldx11,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldx11 | |||
| real(kind=dp), | intent(inout) | :: | x12(ldx12,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldx12 | |||
| real(kind=dp), | intent(inout) | :: | x21(ldx21,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldx21 | |||
| real(kind=dp), | intent(inout) | :: | x22(ldx22,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldx22 | |||
| real(kind=dp), | intent(out) | :: | theta(*) | |||
| real(kind=dp), | intent(out) | :: | u1(ldu1,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldu1 | |||
| real(kind=dp), | intent(out) | :: | u2(ldu2,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldu2 | |||
| real(kind=dp), | intent(out) | :: | v1t(ldv1t,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldv1t | |||
| real(kind=dp), | intent(out) | :: | v2t(ldv2t,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldv2t | |||
| real(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | iwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | jobu1 | |||
| character, | intent(in) | :: | jobu2 | |||
| character, | intent(in) | :: | jobv1t | |||
| character, | intent(in) | :: | jobv2t | |||
| character, | intent(in) | :: | trans | |||
| character, | intent(in) | :: | signs | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | p | |||
| integer(kind=ilp), | intent(in) | :: | q | |||
| real(kind=sp), | intent(inout) | :: | x11(ldx11,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldx11 | |||
| real(kind=sp), | intent(inout) | :: | x12(ldx12,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldx12 | |||
| real(kind=sp), | intent(inout) | :: | x21(ldx21,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldx21 | |||
| real(kind=sp), | intent(inout) | :: | x22(ldx22,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldx22 | |||
| real(kind=sp), | intent(out) | :: | theta(*) | |||
| real(kind=sp), | intent(out) | :: | u1(ldu1,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldu1 | |||
| real(kind=sp), | intent(out) | :: | u2(ldu2,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldu2 | |||
| real(kind=sp), | intent(out) | :: | v1t(ldv1t,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldv1t | |||
| real(kind=sp), | intent(out) | :: | v2t(ldv2t,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldv2t | |||
| real(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | iwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
DORCSD computes the CS decomposition of an M-by-M partitioned orthogonal matrix X: [ I 0 0 | 0 0 0 ] [ 0 C 0 | 0 -S 0 ] [ X11 | X12 ] [ U1 | ] [ 0 0 0 | 0 0 -I ] [ V1 | ]**T X = [-----------] = [---------] [---------------------] [---------] . [ X21 | X22 ] [ | U2 ] [ 0 0 0 | I 0 0 ] [ | V2 ] [ 0 S 0 | 0 C 0 ] [ 0 0 I | 0 0 0 ] X11 is P-by-Q. The orthogonal matrices U1, U2, V1, and V2 are P-by-P, (M-P)-by-(M-P), Q-by-Q, and (M-Q)-by-(M-Q), respectively. C and S are R-by-R nonnegative diagonal matrices satisfying C^2 + S^2 = I, in which R = MIN(P,M-P,Q,M-Q).
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | jobu1 | |||
| character, | intent(in) | :: | jobu2 | |||
| character, | intent(in) | :: | jobv1t | |||
| character, | intent(in) | :: | jobv2t | |||
| character, | intent(in) | :: | trans | |||
| character, | intent(in) | :: | signs | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | p | |||
| integer(kind=ilp), | intent(in) | :: | q | |||
| real(kind=dp), | intent(inout) | :: | x11(ldx11,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldx11 | |||
| real(kind=dp), | intent(inout) | :: | x12(ldx12,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldx12 | |||
| real(kind=dp), | intent(inout) | :: | x21(ldx21,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldx21 | |||
| real(kind=dp), | intent(inout) | :: | x22(ldx22,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldx22 | |||
| real(kind=dp), | intent(out) | :: | theta(*) | |||
| real(kind=dp), | intent(out) | :: | u1(ldu1,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldu1 | |||
| real(kind=dp), | intent(out) | :: | u2(ldu2,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldu2 | |||
| real(kind=dp), | intent(out) | :: | v1t(ldv1t,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldv1t | |||
| real(kind=dp), | intent(out) | :: | v2t(ldv2t,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldv2t | |||
| real(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | iwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
SORCSD computes the CS decomposition of an M-by-M partitioned orthogonal matrix X: [ I 0 0 | 0 0 0 ] [ 0 C 0 | 0 -S 0 ] [ X11 | X12 ] [ U1 | ] [ 0 0 0 | 0 0 -I ] [ V1 | ]**T X = [-----------] = [---------] [---------------------] [---------] . [ X21 | X22 ] [ | U2 ] [ 0 0 0 | I 0 0 ] [ | V2 ] [ 0 S 0 | 0 C 0 ] [ 0 0 I | 0 0 0 ] X11 is P-by-Q. The orthogonal matrices U1, U2, V1, and V2 are P-by-P, (M-P)-by-(M-P), Q-by-Q, and (M-Q)-by-(M-Q), respectively. C and S are R-by-R nonnegative diagonal matrices satisfying C^2 + S^2 = I, in which R = MIN(P,M-P,Q,M-Q).
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | jobu1 | |||
| character, | intent(in) | :: | jobu2 | |||
| character, | intent(in) | :: | jobv1t | |||
| character, | intent(in) | :: | jobv2t | |||
| character, | intent(in) | :: | trans | |||
| character, | intent(in) | :: | signs | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | p | |||
| integer(kind=ilp), | intent(in) | :: | q | |||
| real(kind=sp), | intent(inout) | :: | x11(ldx11,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldx11 | |||
| real(kind=sp), | intent(inout) | :: | x12(ldx12,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldx12 | |||
| real(kind=sp), | intent(inout) | :: | x21(ldx21,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldx21 | |||
| real(kind=sp), | intent(inout) | :: | x22(ldx22,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldx22 | |||
| real(kind=sp), | intent(out) | :: | theta(*) | |||
| real(kind=sp), | intent(out) | :: | u1(ldu1,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldu1 | |||
| real(kind=sp), | intent(out) | :: | u2(ldu2,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldu2 | |||
| real(kind=sp), | intent(out) | :: | v1t(ldv1t,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldv1t | |||
| real(kind=sp), | intent(out) | :: | v2t(ldv2t,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldv2t | |||
| real(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | iwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
ORCSD2BY1 computes the CS decomposition of an M-by-Q matrix X with orthonormal columns that has been partitioned into a 2-by-1 block structure: [ I1 0 0 ] [ 0 C 0 ] [ X11 ] [ U1 | ] [ 0 0 0 ] X = [-----] = [---------] [----------] V1**T . [ X21 ] [ | U2 ] [ 0 0 0 ] [ 0 S 0 ] [ 0 0 I2] X11 is P-by-Q. The orthogonal matrices U1, U2, and V1 are P-by-P, (M-P)-by-(M-P), and Q-by-Q, respectively. C and S are R-by-R nonnegative diagonal matrices satisfying C^2 + S^2 = I, in which R = MIN(P,M-P,Q,M-Q). I1 is a K1-by-K1 identity matrix and I2 is a K2-by-K2 identity matrix, where K1 = MAX(Q+P-M,0), K2 = MAX(Q-P,0).
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | jobu1 | |||
| character, | intent(in) | :: | jobu2 | |||
| character, | intent(in) | :: | jobv1t | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | p | |||
| integer(kind=ilp), | intent(in) | :: | q | |||
| real(kind=dp), | intent(inout) | :: | x11(ldx11,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldx11 | |||
| real(kind=dp), | intent(inout) | :: | x21(ldx21,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldx21 | |||
| real(kind=dp), | intent(out) | :: | theta(*) | |||
| real(kind=dp), | intent(out) | :: | u1(ldu1,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldu1 | |||
| real(kind=dp), | intent(out) | :: | u2(ldu2,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldu2 | |||
| real(kind=dp), | intent(out) | :: | v1t(ldv1t,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldv1t | |||
| real(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | iwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | jobu1 | |||
| character, | intent(in) | :: | jobu2 | |||
| character, | intent(in) | :: | jobv1t | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | p | |||
| integer(kind=ilp), | intent(in) | :: | q | |||
| real(kind=sp), | intent(inout) | :: | x11(ldx11,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldx11 | |||
| real(kind=sp), | intent(inout) | :: | x21(ldx21,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldx21 | |||
| real(kind=sp), | intent(out) | :: | theta(*) | |||
| real(kind=sp), | intent(out) | :: | u1(ldu1,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldu1 | |||
| real(kind=sp), | intent(out) | :: | u2(ldu2,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldu2 | |||
| real(kind=sp), | intent(out) | :: | v1t(ldv1t,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldv1t | |||
| real(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | iwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
DORCSD2BY1 computes the CS decomposition of an M-by-Q matrix X with orthonormal columns that has been partitioned into a 2-by-1 block structure: [ I1 0 0 ] [ 0 C 0 ] [ X11 ] [ U1 | ] [ 0 0 0 ] X = [-----] = [---------] [----------] V1**T . [ X21 ] [ | U2 ] [ 0 0 0 ] [ 0 S 0 ] [ 0 0 I2] X11 is P-by-Q. The orthogonal matrices U1, U2, and V1 are P-by-P, (M-P)-by-(M-P), and Q-by-Q, respectively. C and S are R-by-R nonnegative diagonal matrices satisfying C^2 + S^2 = I, in which R = MIN(P,M-P,Q,M-Q). I1 is a K1-by-K1 identity matrix and I2 is a K2-by-K2 identity matrix, where K1 = MAX(Q+P-M,0), K2 = MAX(Q-P,0).
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | jobu1 | |||
| character, | intent(in) | :: | jobu2 | |||
| character, | intent(in) | :: | jobv1t | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | p | |||
| integer(kind=ilp), | intent(in) | :: | q | |||
| real(kind=dp), | intent(inout) | :: | x11(ldx11,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldx11 | |||
| real(kind=dp), | intent(inout) | :: | x21(ldx21,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldx21 | |||
| real(kind=dp), | intent(out) | :: | theta(*) | |||
| real(kind=dp), | intent(out) | :: | u1(ldu1,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldu1 | |||
| real(kind=dp), | intent(out) | :: | u2(ldu2,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldu2 | |||
| real(kind=dp), | intent(out) | :: | v1t(ldv1t,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldv1t | |||
| real(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | iwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
SORCSD2BY1 computes the CS decomposition of an M-by-Q matrix X with orthonormal columns that has been partitioned into a 2-by-1 block structure: [ I1 0 0 ] [ 0 C 0 ] [ X11 ] [ U1 | ] [ 0 0 0 ] X = [-----] = [---------] [----------] V1**T . [ X21 ] [ | U2 ] [ 0 0 0 ] [ 0 S 0 ] [ 0 0 I2] X11 is P-by-Q. The orthogonal matrices U1, U2, and V1 are P-by-P, (M-P)-by-(M-P), and Q-by-Q, respectively. C and S are R-by-R nonnegative diagonal matrices satisfying C^2 + S^2 = I, in which R = MIN(P,M-P,Q,M-Q). I1 is a K1-by-K1 identity matrix and I2 is a K2-by-K2 identity matrix, where K1 = MAX(Q+P-M,0), K2 = MAX(Q-P,0).
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | jobu1 | |||
| character, | intent(in) | :: | jobu2 | |||
| character, | intent(in) | :: | jobv1t | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | p | |||
| integer(kind=ilp), | intent(in) | :: | q | |||
| real(kind=sp), | intent(inout) | :: | x11(ldx11,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldx11 | |||
| real(kind=sp), | intent(inout) | :: | x21(ldx21,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldx21 | |||
| real(kind=sp), | intent(out) | :: | theta(*) | |||
| real(kind=sp), | intent(out) | :: | u1(ldu1,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldu1 | |||
| real(kind=sp), | intent(out) | :: | u2(ldu2,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldu2 | |||
| real(kind=sp), | intent(out) | :: | v1t(ldv1t,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldv1t | |||
| real(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | iwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
ORG2L generates an m by n real matrix Q with orthonormal columns, which is defined as the last n columns of a product of k elementary reflectors of order m Q = H(k) . . . H(2) H(1) as returned by DGEQLF.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | k | |||
| real(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=dp), | intent(in) | :: | tau(*) | |||
| real(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | k | |||
| real(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=sp), | intent(in) | :: | tau(*) | |||
| real(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
DORG2L generates an m by n real matrix Q with orthonormal columns, which is defined as the last n columns of a product of k elementary reflectors of order m Q = H(k) . . . H(2) H(1) as returned by DGEQLF.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | k | |||
| real(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=dp), | intent(in) | :: | tau(*) | |||
| real(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
SORG2L generates an m by n real matrix Q with orthonormal columns, which is defined as the last n columns of a product of k elementary reflectors of order m Q = H(k) . . . H(2) H(1) as returned by SGEQLF.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | k | |||
| real(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=sp), | intent(in) | :: | tau(*) | |||
| real(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
ORG2R generates an m by n real matrix Q with orthonormal columns, which is defined as the first n columns of a product of k elementary reflectors of order m Q = H(1) H(2) . . . H(k) as returned by DGEQRF.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | k | |||
| real(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=dp), | intent(in) | :: | tau(*) | |||
| real(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | k | |||
| real(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=sp), | intent(in) | :: | tau(*) | |||
| real(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
DORG2R generates an m by n real matrix Q with orthonormal columns, which is defined as the first n columns of a product of k elementary reflectors of order m Q = H(1) H(2) . . . H(k) as returned by DGEQRF.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | k | |||
| real(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=dp), | intent(in) | :: | tau(*) | |||
| real(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
SORG2R generates an m by n real matrix Q with orthonormal columns, which is defined as the first n columns of a product of k elementary reflectors of order m Q = H(1) H(2) . . . H(k) as returned by SGEQRF.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | k | |||
| real(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=sp), | intent(in) | :: | tau(*) | |||
| real(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
ORGBR generates one of the real orthogonal matrices Q or PT determined by DGEBRD when reducing a real matrix A to bidiagonal form: A = Q * B * PT. Q and PT are defined as products of elementary reflectors H(i) or G(i) respectively. If VECT = 'Q', A is assumed to have been an M-by-K matrix, and Q is of order M: if m >= k, Q = H(1) H(2) . . . H(k) and ORGBR returns the first n columns of Q, where m >= n >= k; if m < k, Q = H(1) H(2) . . . H(m-1) and ORGBR returns Q as an M-by-M matrix. If VECT = 'P', A is assumed to have been a K-by-N matrix, and PT is of order N: if k < n, PT = G(k) . . . G(2) G(1) and ORGBR returns the first m rows of PT, where n >= m >= k; if k >= n, PT = G(n-1) . . . G(2) G(1) and ORGBR returns PT as an N-by-N matrix.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | vect | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | k | |||
| real(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=dp), | intent(in) | :: | tau(*) | |||
| real(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | vect | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | k | |||
| real(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=sp), | intent(in) | :: | tau(*) | |||
| real(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
DORGBR generates one of the real orthogonal matrices Q or PT determined by DGEBRD when reducing a real matrix A to bidiagonal form: A = Q * B * PT. Q and PT are defined as products of elementary reflectors H(i) or G(i) respectively. If VECT = 'Q', A is assumed to have been an M-by-K matrix, and Q is of order M: if m >= k, Q = H(1) H(2) . . . H(k) and DORGBR returns the first n columns of Q, where m >= n >= k; if m < k, Q = H(1) H(2) . . . H(m-1) and DORGBR returns Q as an M-by-M matrix. If VECT = 'P', A is assumed to have been a K-by-N matrix, and PT is of order N: if k < n, PT = G(k) . . . G(2) G(1) and DORGBR returns the first m rows of PT, where n >= m >= k; if k >= n, PT = G(n-1) . . . G(2) G(1) and DORGBR returns PT as an N-by-N matrix.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | vect | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | k | |||
| real(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=dp), | intent(in) | :: | tau(*) | |||
| real(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
SORGBR generates one of the real orthogonal matrices Q or PT determined by SGEBRD when reducing a real matrix A to bidiagonal form: A = Q * B * PT. Q and PT are defined as products of elementary reflectors H(i) or G(i) respectively. If VECT = 'Q', A is assumed to have been an M-by-K matrix, and Q is of order M: if m >= k, Q = H(1) H(2) . . . H(k) and SORGBR returns the first n columns of Q, where m >= n >= k; if m < k, Q = H(1) H(2) . . . H(m-1) and SORGBR returns Q as an M-by-M matrix. If VECT = 'P', A is assumed to have been a K-by-N matrix, and PT is of order N: if k < n, PT = G(k) . . . G(2) G(1) and SORGBR returns the first m rows of PT, where n >= m >= k; if k >= n, PT = G(n-1) . . . G(2) G(1) and SORGBR returns PT as an N-by-N matrix.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | vect | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | k | |||
| real(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=sp), | intent(in) | :: | tau(*) | |||
| real(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
ORGHR generates a real orthogonal matrix Q which is defined as the product of IHI-ILO elementary reflectors of order N, as returned by DGEHRD: Q = H(ilo) H(ilo+1) . . . H(ihi-1).
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | ilo | |||
| integer(kind=ilp), | intent(in) | :: | ihi | |||
| real(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=dp), | intent(in) | :: | tau(*) | |||
| real(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | ilo | |||
| integer(kind=ilp), | intent(in) | :: | ihi | |||
| real(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=sp), | intent(in) | :: | tau(*) | |||
| real(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
DORGHR generates a real orthogonal matrix Q which is defined as the product of IHI-ILO elementary reflectors of order N, as returned by DGEHRD: Q = H(ilo) H(ilo+1) . . . H(ihi-1).
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | ilo | |||
| integer(kind=ilp), | intent(in) | :: | ihi | |||
| real(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=dp), | intent(in) | :: | tau(*) | |||
| real(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
SORGHR generates a real orthogonal matrix Q which is defined as the product of IHI-ILO elementary reflectors of order N, as returned by SGEHRD: Q = H(ilo) H(ilo+1) . . . H(ihi-1).
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | ilo | |||
| integer(kind=ilp), | intent(in) | :: | ihi | |||
| real(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=sp), | intent(in) | :: | tau(*) | |||
| real(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
ORGLQ generates an M-by-N real matrix Q with orthonormal rows, which is defined as the first M rows of a product of K elementary reflectors of order N Q = H(k) . . . H(2) H(1) as returned by DGELQF.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | k | |||
| real(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=dp), | intent(in) | :: | tau(*) | |||
| real(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | k | |||
| real(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=sp), | intent(in) | :: | tau(*) | |||
| real(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
DORGLQ generates an M-by-N real matrix Q with orthonormal rows, which is defined as the first M rows of a product of K elementary reflectors of order N Q = H(k) . . . H(2) H(1) as returned by DGELQF.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | k | |||
| real(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=dp), | intent(in) | :: | tau(*) | |||
| real(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
SORGLQ generates an M-by-N real matrix Q with orthonormal rows, which is defined as the first M rows of a product of K elementary reflectors of order N Q = H(k) . . . H(2) H(1) as returned by SGELQF.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | k | |||
| real(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=sp), | intent(in) | :: | tau(*) | |||
| real(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
ORGQL generates an M-by-N real matrix Q with orthonormal columns, which is defined as the last N columns of a product of K elementary reflectors of order M Q = H(k) . . . H(2) H(1) as returned by DGEQLF.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | k | |||
| real(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=dp), | intent(in) | :: | tau(*) | |||
| real(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | k | |||
| real(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=sp), | intent(in) | :: | tau(*) | |||
| real(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
DORGQL generates an M-by-N real matrix Q with orthonormal columns, which is defined as the last N columns of a product of K elementary reflectors of order M Q = H(k) . . . H(2) H(1) as returned by DGEQLF.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | k | |||
| real(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=dp), | intent(in) | :: | tau(*) | |||
| real(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
SORGQL generates an M-by-N real matrix Q with orthonormal columns, which is defined as the last N columns of a product of K elementary reflectors of order M Q = H(k) . . . H(2) H(1) as returned by SGEQLF.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | k | |||
| real(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=sp), | intent(in) | :: | tau(*) | |||
| real(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
ORGQR generates an M-by-N real matrix Q with orthonormal columns, which is defined as the first N columns of a product of K elementary reflectors of order M Q = H(1) H(2) . . . H(k) as returned by DGEQRF.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | k | |||
| real(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=dp), | intent(in) | :: | tau(*) | |||
| real(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | k | |||
| real(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=sp), | intent(in) | :: | tau(*) | |||
| real(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
DORGQR generates an M-by-N real matrix Q with orthonormal columns, which is defined as the first N columns of a product of K elementary reflectors of order M Q = H(1) H(2) . . . H(k) as returned by DGEQRF.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | k | |||
| real(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=dp), | intent(in) | :: | tau(*) | |||
| real(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
SORGQR generates an M-by-N real matrix Q with orthonormal columns, which is defined as the first N columns of a product of K elementary reflectors of order M Q = H(1) H(2) . . . H(k) as returned by SGEQRF.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | k | |||
| real(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=sp), | intent(in) | :: | tau(*) | |||
| real(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
ORGRQ generates an M-by-N real matrix Q with orthonormal rows, which is defined as the last M rows of a product of K elementary reflectors of order N Q = H(1) H(2) . . . H(k) as returned by DGERQF.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | k | |||
| real(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=dp), | intent(in) | :: | tau(*) | |||
| real(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | k | |||
| real(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=sp), | intent(in) | :: | tau(*) | |||
| real(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
DORGRQ generates an M-by-N real matrix Q with orthonormal rows, which is defined as the last M rows of a product of K elementary reflectors of order N Q = H(1) H(2) . . . H(k) as returned by DGERQF.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | k | |||
| real(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=dp), | intent(in) | :: | tau(*) | |||
| real(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
SORGRQ generates an M-by-N real matrix Q with orthonormal rows, which is defined as the last M rows of a product of K elementary reflectors of order N Q = H(1) H(2) . . . H(k) as returned by SGERQF.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | k | |||
| real(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=sp), | intent(in) | :: | tau(*) | |||
| real(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
ORGTR generates a real orthogonal matrix Q which is defined as the product of n-1 elementary reflectors of order N, as returned by DSYTRD: if UPLO = 'U', Q = H(n-1) . . . H(2) H(1), if UPLO = 'L', Q = H(1) H(2) . . . H(n-1).
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=dp), | intent(in) | :: | tau(*) | |||
| real(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=sp), | intent(in) | :: | tau(*) | |||
| real(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
DORGTR generates a real orthogonal matrix Q which is defined as the product of n-1 elementary reflectors of order N, as returned by DSYTRD: if UPLO = 'U', Q = H(n-1) . . . H(2) H(1), if UPLO = 'L', Q = H(1) H(2) . . . H(n-1).
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=dp), | intent(in) | :: | tau(*) | |||
| real(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
SORGTR generates a real orthogonal matrix Q which is defined as the product of n-1 elementary reflectors of order N, as returned by SSYTRD: if UPLO = 'U', Q = H(n-1) . . . H(2) H(1), if UPLO = 'L', Q = H(1) H(2) . . . H(n-1).
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=sp), | intent(in) | :: | tau(*) | |||
| real(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
ORGTSQR generates an M-by-N real matrix Q_out with orthonormal columns, which are the first N columns of a product of real orthogonal matrices of order M which are returned by DLATSQR Q_out = first_N_columns_of( Q(1)_in * Q(2)_in * ... * Q(k)_in ). See the documentation for DLATSQR.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | mb | |||
| integer(kind=ilp), | intent(in) | :: | nb | |||
| real(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=dp), | intent(in) | :: | t(ldt,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldt | |||
| real(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | mb | |||
| integer(kind=ilp), | intent(in) | :: | nb | |||
| real(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=sp), | intent(in) | :: | t(ldt,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldt | |||
| real(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
DORGTSQR generates an M-by-N real matrix Q_out with orthonormal columns, which are the first N columns of a product of real orthogonal matrices of order M which are returned by DLATSQR Q_out = first_N_columns_of( Q(1)_in * Q(2)_in * ... * Q(k)_in ). See the documentation for DLATSQR.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | mb | |||
| integer(kind=ilp), | intent(in) | :: | nb | |||
| real(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=dp), | intent(in) | :: | t(ldt,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldt | |||
| real(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
SORGTSQR generates an M-by-N real matrix Q_out with orthonormal columns, which are the first N columns of a product of real orthogonal matrices of order M which are returned by SLATSQR Q_out = first_N_columns_of( Q(1)_in * Q(2)_in * ... * Q(k)_in ). See the documentation for SLATSQR.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | mb | |||
| integer(kind=ilp), | intent(in) | :: | nb | |||
| real(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=sp), | intent(in) | :: | t(ldt,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldt | |||
| real(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
ORGTSQR_ROW generates an M-by-N real matrix Q_out with orthonormal columns from the output of DLATSQR. These N orthonormal columns are the first N columns of a product of complex unitary matrices Q(k)_in of order M, which are returned by DLATSQR in a special format. Q_out = first_N_columns_of( Q(1)_in * Q(2)_in * ... * Q(k)_in ). The input matrices Q(k)_in are stored in row and column blocks in A. See the documentation of DLATSQR for more details on the format of Q(k)_in, where each Q(k)_in is represented by block Householder transformations. This routine calls an auxiliary routine DLARFB_GETT, where the computation is performed on each individual block. The algorithm first sweeps NB-sized column blocks from the right to left starting in the bottom row block and continues to the top row block (hence _ROW in the routine name). This sweep is in reverse order of the order in which DLATSQR generates the output blocks.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | mb | |||
| integer(kind=ilp), | intent(in) | :: | nb | |||
| real(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=dp), | intent(in) | :: | t(ldt,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldt | |||
| real(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | mb | |||
| integer(kind=ilp), | intent(in) | :: | nb | |||
| real(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=sp), | intent(in) | :: | t(ldt,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldt | |||
| real(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
DORGTSQR_ROW generates an M-by-N real matrix Q_out with orthonormal columns from the output of DLATSQR. These N orthonormal columns are the first N columns of a product of complex unitary matrices Q(k)_in of order M, which are returned by DLATSQR in a special format. Q_out = first_N_columns_of( Q(1)_in * Q(2)_in * ... * Q(k)_in ). The input matrices Q(k)_in are stored in row and column blocks in A. See the documentation of DLATSQR for more details on the format of Q(k)_in, where each Q(k)_in is represented by block Householder transformations. This routine calls an auxiliary routine DLARFB_GETT, where the computation is performed on each individual block. The algorithm first sweeps NB-sized column blocks from the right to left starting in the bottom row block and continues to the top row block (hence _ROW in the routine name). This sweep is in reverse order of the order in which DLATSQR generates the output blocks.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | mb | |||
| integer(kind=ilp), | intent(in) | :: | nb | |||
| real(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=dp), | intent(in) | :: | t(ldt,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldt | |||
| real(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
SORGTSQR_ROW generates an M-by-N real matrix Q_out with orthonormal columns from the output of SLATSQR. These N orthonormal columns are the first N columns of a product of complex unitary matrices Q(k)_in of order M, which are returned by SLATSQR in a special format. Q_out = first_N_columns_of( Q(1)_in * Q(2)_in * ... * Q(k)_in ). The input matrices Q(k)_in are stored in row and column blocks in A. See the documentation of SLATSQR for more details on the format of Q(k)_in, where each Q(k)_in is represented by block Householder transformations. This routine calls an auxiliary routine SLARFB_GETT, where the computation is performed on each individual block. The algorithm first sweeps NB-sized column blocks from the right to left starting in the bottom row block and continues to the top row block (hence _ROW in the routine name). This sweep is in reverse order of the order in which SLATSQR generates the output blocks.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | mb | |||
| integer(kind=ilp), | intent(in) | :: | nb | |||
| real(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=sp), | intent(in) | :: | t(ldt,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldt | |||
| real(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
ORHR_COL takes an M-by-N real matrix Q_in with orthonormal columns as input, stored in A, and performs Householder Reconstruction (HR), i.e. reconstructs Householder vectors V(i) implicitly representing another M-by-N matrix Q_out, with the property that Q_in = Q_out*S, where S is an N-by-N diagonal matrix with diagonal entries equal to +1 or -1. The Householder vectors (columns V(i) of V) are stored in A on output, and the diagonal entries of S are stored in D. Block reflectors are also returned in T (same output format as DGEQRT).
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nb | |||
| real(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=dp), | intent(out) | :: | t(ldt,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldt | |||
| real(kind=dp), | intent(out) | :: | d(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nb | |||
| real(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=sp), | intent(out) | :: | t(ldt,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldt | |||
| real(kind=sp), | intent(out) | :: | d(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
DORHR_COL takes an M-by-N real matrix Q_in with orthonormal columns as input, stored in A, and performs Householder Reconstruction (HR), i.e. reconstructs Householder vectors V(i) implicitly representing another M-by-N matrix Q_out, with the property that Q_in = Q_out*S, where S is an N-by-N diagonal matrix with diagonal entries equal to +1 or -1. The Householder vectors (columns V(i) of V) are stored in A on output, and the diagonal entries of S are stored in D. Block reflectors are also returned in T (same output format as DGEQRT).
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nb | |||
| real(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=dp), | intent(out) | :: | t(ldt,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldt | |||
| real(kind=dp), | intent(out) | :: | d(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
SORHR_COL takes an M-by-N real matrix Q_in with orthonormal columns as input, stored in A, and performs Householder Reconstruction (HR), i.e. reconstructs Householder vectors V(i) implicitly representing another M-by-N matrix Q_out, with the property that Q_in = Q_out*S, where S is an N-by-N diagonal matrix with diagonal entries equal to +1 or -1. The Householder vectors (columns V(i) of V) are stored in A on output, and the diagonal entries of S are stored in D. Block reflectors are also returned in T (same output format as SGEQRT).
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nb | |||
| real(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=sp), | intent(out) | :: | t(ldt,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldt | |||
| real(kind=sp), | intent(out) | :: | d(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
ORM2L overwrites the general real m by n matrix C with Q * C if SIDE = 'L' and TRANS = 'N', or QT * C if SIDE = 'L' and TRANS = 'T', or C * Q if SIDE = 'R' and TRANS = 'N', or C * QT if SIDE = 'R' and TRANS = 'T', where Q is a real orthogonal matrix defined as the product of k elementary reflectors Q = H(k) . . . H(2) H(1) as returned by DGEQLF. Q is of order m if SIDE = 'L' and of order n if SIDE = 'R'.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | side | |||
| character, | intent(in) | :: | trans | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | k | |||
| real(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=dp), | intent(in) | :: | tau(*) | |||
| real(kind=dp), | intent(inout) | :: | c(ldc,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldc | |||
| real(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | side | |||
| character, | intent(in) | :: | trans | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | k | |||
| real(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=sp), | intent(in) | :: | tau(*) | |||
| real(kind=sp), | intent(inout) | :: | c(ldc,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldc | |||
| real(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
DORM2L overwrites the general real m by n matrix C with Q * C if SIDE = 'L' and TRANS = 'N', or QT * C if SIDE = 'L' and TRANS = 'T', or C * Q if SIDE = 'R' and TRANS = 'N', or C * QT if SIDE = 'R' and TRANS = 'T', where Q is a real orthogonal matrix defined as the product of k elementary reflectors Q = H(k) . . . H(2) H(1) as returned by DGEQLF. Q is of order m if SIDE = 'L' and of order n if SIDE = 'R'.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | side | |||
| character, | intent(in) | :: | trans | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | k | |||
| real(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=dp), | intent(in) | :: | tau(*) | |||
| real(kind=dp), | intent(inout) | :: | c(ldc,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldc | |||
| real(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
SORM2L overwrites the general real m by n matrix C with Q * C if SIDE = 'L' and TRANS = 'N', or QT * C if SIDE = 'L' and TRANS = 'T', or C * Q if SIDE = 'R' and TRANS = 'N', or C * QT if SIDE = 'R' and TRANS = 'T', where Q is a real orthogonal matrix defined as the product of k elementary reflectors Q = H(k) . . . H(2) H(1) as returned by SGEQLF. Q is of order m if SIDE = 'L' and of order n if SIDE = 'R'.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | side | |||
| character, | intent(in) | :: | trans | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | k | |||
| real(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=sp), | intent(in) | :: | tau(*) | |||
| real(kind=sp), | intent(inout) | :: | c(ldc,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldc | |||
| real(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
ORM2R overwrites the general real m by n matrix C with Q * C if SIDE = 'L' and TRANS = 'N', or QT* C if SIDE = 'L' and TRANS = 'T', or C * Q if SIDE = 'R' and TRANS = 'N', or C * QT if SIDE = 'R' and TRANS = 'T', where Q is a real orthogonal matrix defined as the product of k elementary reflectors Q = H(1) H(2) . . . H(k) as returned by DGEQRF. Q is of order m if SIDE = 'L' and of order n if SIDE = 'R'.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | side | |||
| character, | intent(in) | :: | trans | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | k | |||
| real(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=dp), | intent(in) | :: | tau(*) | |||
| real(kind=dp), | intent(inout) | :: | c(ldc,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldc | |||
| real(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | side | |||
| character, | intent(in) | :: | trans | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | k | |||
| real(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=sp), | intent(in) | :: | tau(*) | |||
| real(kind=sp), | intent(inout) | :: | c(ldc,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldc | |||
| real(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
DORM2R overwrites the general real m by n matrix C with Q * C if SIDE = 'L' and TRANS = 'N', or QT* C if SIDE = 'L' and TRANS = 'T', or C * Q if SIDE = 'R' and TRANS = 'N', or C * QT if SIDE = 'R' and TRANS = 'T', where Q is a real orthogonal matrix defined as the product of k elementary reflectors Q = H(1) H(2) . . . H(k) as returned by DGEQRF. Q is of order m if SIDE = 'L' and of order n if SIDE = 'R'.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | side | |||
| character, | intent(in) | :: | trans | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | k | |||
| real(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=dp), | intent(in) | :: | tau(*) | |||
| real(kind=dp), | intent(inout) | :: | c(ldc,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldc | |||
| real(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
SORM2R overwrites the general real m by n matrix C with Q * C if SIDE = 'L' and TRANS = 'N', or QT* C if SIDE = 'L' and TRANS = 'T', or C * Q if SIDE = 'R' and TRANS = 'N', or C * QT if SIDE = 'R' and TRANS = 'T', where Q is a real orthogonal matrix defined as the product of k elementary reflectors Q = H(1) H(2) . . . H(k) as returned by SGEQRF. Q is of order m if SIDE = 'L' and of order n if SIDE = 'R'.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | side | |||
| character, | intent(in) | :: | trans | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | k | |||
| real(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=sp), | intent(in) | :: | tau(*) | |||
| real(kind=sp), | intent(inout) | :: | c(ldc,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldc | |||
| real(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
If VECT = 'Q', ORMBR: overwrites the general real M-by-N matrix C with SIDE = 'L' SIDE = 'R' TRANS = 'N': Q * C C * Q TRANS = 'T': QT * C C * QT If VECT = 'P', ORMBR overwrites the general real M-by-N matrix C with SIDE = 'L' SIDE = 'R' TRANS = 'N': P * C C * P TRANS = 'T': PT * C C * PT Here Q and PT are the orthogonal matrices determined by DGEBRD when reducing a real matrix A to bidiagonal form: A = Q * B * PT. Q and PT are defined as products of elementary reflectors H(i) and G(i) respectively. Let nq = m if SIDE = 'L' and nq = n if SIDE = 'R'. Thus nq is the order of the orthogonal matrix Q or PT that is applied. If VECT = 'Q', A is assumed to have been an NQ-by-K matrix: if nq >= k, Q = H(1) H(2) . . . H(k); if nq < k, Q = H(1) H(2) . . . H(nq-1). If VECT = 'P', A is assumed to have been a K-by-NQ matrix: if k < nq, P = G(1) G(2) . . . G(k); if k >= nq, P = G(1) G(2) . . . G(nq-1).
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | vect | |||
| character, | intent(in) | :: | side | |||
| character, | intent(in) | :: | trans | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | k | |||
| real(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=dp), | intent(in) | :: | tau(*) | |||
| real(kind=dp), | intent(inout) | :: | c(ldc,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldc | |||
| real(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | vect | |||
| character, | intent(in) | :: | side | |||
| character, | intent(in) | :: | trans | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | k | |||
| real(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=sp), | intent(in) | :: | tau(*) | |||
| real(kind=sp), | intent(inout) | :: | c(ldc,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldc | |||
| real(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
If VECT = 'Q', DORMBR: overwrites the general real M-by-N matrix C with SIDE = 'L' SIDE = 'R' TRANS = 'N': Q * C C * Q TRANS = 'T': QT * C C * QT If VECT = 'P', DORMBR overwrites the general real M-by-N matrix C with SIDE = 'L' SIDE = 'R' TRANS = 'N': P * C C * P TRANS = 'T': PT * C C * PT Here Q and PT are the orthogonal matrices determined by DGEBRD when reducing a real matrix A to bidiagonal form: A = Q * B * PT. Q and PT are defined as products of elementary reflectors H(i) and G(i) respectively. Let nq = m if SIDE = 'L' and nq = n if SIDE = 'R'. Thus nq is the order of the orthogonal matrix Q or PT that is applied. If VECT = 'Q', A is assumed to have been an NQ-by-K matrix: if nq >= k, Q = H(1) H(2) . . . H(k); if nq < k, Q = H(1) H(2) . . . H(nq-1). If VECT = 'P', A is assumed to have been a K-by-NQ matrix: if k < nq, P = G(1) G(2) . . . G(k); if k >= nq, P = G(1) G(2) . . . G(nq-1).
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | vect | |||
| character, | intent(in) | :: | side | |||
| character, | intent(in) | :: | trans | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | k | |||
| real(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=dp), | intent(in) | :: | tau(*) | |||
| real(kind=dp), | intent(inout) | :: | c(ldc,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldc | |||
| real(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
If VECT = 'Q', SORMBR: overwrites the general real M-by-N matrix C with SIDE = 'L' SIDE = 'R' TRANS = 'N': Q * C C * Q TRANS = 'T': QT * C C * QT If VECT = 'P', SORMBR overwrites the general real M-by-N matrix C with SIDE = 'L' SIDE = 'R' TRANS = 'N': P * C C * P TRANS = 'T': PT * C C * PT Here Q and PT are the orthogonal matrices determined by SGEBRD when reducing a real matrix A to bidiagonal form: A = Q * B * PT. Q and PT are defined as products of elementary reflectors H(i) and G(i) respectively. Let nq = m if SIDE = 'L' and nq = n if SIDE = 'R'. Thus nq is the order of the orthogonal matrix Q or PT that is applied. If VECT = 'Q', A is assumed to have been an NQ-by-K matrix: if nq >= k, Q = H(1) H(2) . . . H(k); if nq < k, Q = H(1) H(2) . . . H(nq-1). If VECT = 'P', A is assumed to have been a K-by-NQ matrix: if k < nq, P = G(1) G(2) . . . G(k); if k >= nq, P = G(1) G(2) . . . G(nq-1).
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | vect | |||
| character, | intent(in) | :: | side | |||
| character, | intent(in) | :: | trans | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | k | |||
| real(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=sp), | intent(in) | :: | tau(*) | |||
| real(kind=sp), | intent(inout) | :: | c(ldc,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldc | |||
| real(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
ORMHR overwrites the general real M-by-N matrix C with SIDE = 'L' SIDE = 'R' TRANS = 'N': Q * C C * Q TRANS = 'T': QT * C C * QT where Q is a real orthogonal matrix of order nq, with nq = m if SIDE = 'L' and nq = n if SIDE = 'R'. Q is defined as the product of IHI-ILO elementary reflectors, as returned by DGEHRD: Q = H(ilo) H(ilo+1) . . . H(ihi-1).
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | side | |||
| character, | intent(in) | :: | trans | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | ilo | |||
| integer(kind=ilp), | intent(in) | :: | ihi | |||
| real(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=dp), | intent(in) | :: | tau(*) | |||
| real(kind=dp), | intent(inout) | :: | c(ldc,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldc | |||
| real(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | side | |||
| character, | intent(in) | :: | trans | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | ilo | |||
| integer(kind=ilp), | intent(in) | :: | ihi | |||
| real(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=sp), | intent(in) | :: | tau(*) | |||
| real(kind=sp), | intent(inout) | :: | c(ldc,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldc | |||
| real(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
DORMHR overwrites the general real M-by-N matrix C with SIDE = 'L' SIDE = 'R' TRANS = 'N': Q * C C * Q TRANS = 'T': QT * C C * QT where Q is a real orthogonal matrix of order nq, with nq = m if SIDE = 'L' and nq = n if SIDE = 'R'. Q is defined as the product of IHI-ILO elementary reflectors, as returned by DGEHRD: Q = H(ilo) H(ilo+1) . . . H(ihi-1).
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | side | |||
| character, | intent(in) | :: | trans | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | ilo | |||
| integer(kind=ilp), | intent(in) | :: | ihi | |||
| real(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=dp), | intent(in) | :: | tau(*) | |||
| real(kind=dp), | intent(inout) | :: | c(ldc,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldc | |||
| real(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
SORMHR overwrites the general real M-by-N matrix C with SIDE = 'L' SIDE = 'R' TRANS = 'N': Q * C C * Q TRANS = 'T': QT * C C * QT where Q is a real orthogonal matrix of order nq, with nq = m if SIDE = 'L' and nq = n if SIDE = 'R'. Q is defined as the product of IHI-ILO elementary reflectors, as returned by SGEHRD: Q = H(ilo) H(ilo+1) . . . H(ihi-1).
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | side | |||
| character, | intent(in) | :: | trans | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | ilo | |||
| integer(kind=ilp), | intent(in) | :: | ihi | |||
| real(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=sp), | intent(in) | :: | tau(*) | |||
| real(kind=sp), | intent(inout) | :: | c(ldc,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldc | |||
| real(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
ORMLQ overwrites the general real M-by-N matrix C with SIDE = 'L' SIDE = 'R' TRANS = 'N': Q * C C * Q TRANS = 'T': QT * C C * QT where Q is a real orthogonal matrix defined as the product of k elementary reflectors Q = H(k) . . . H(2) H(1) as returned by DGELQF. Q is of order M if SIDE = 'L' and of order N if SIDE = 'R'.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | side | |||
| character, | intent(in) | :: | trans | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | k | |||
| real(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=dp), | intent(in) | :: | tau(*) | |||
| real(kind=dp), | intent(inout) | :: | c(ldc,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldc | |||
| real(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | side | |||
| character, | intent(in) | :: | trans | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | k | |||
| real(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=sp), | intent(in) | :: | tau(*) | |||
| real(kind=sp), | intent(inout) | :: | c(ldc,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldc | |||
| real(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
DORMLQ overwrites the general real M-by-N matrix C with SIDE = 'L' SIDE = 'R' TRANS = 'N': Q * C C * Q TRANS = 'T': QT * C C * QT where Q is a real orthogonal matrix defined as the product of k elementary reflectors Q = H(k) . . . H(2) H(1) as returned by DGELQF. Q is of order M if SIDE = 'L' and of order N if SIDE = 'R'.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | side | |||
| character, | intent(in) | :: | trans | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | k | |||
| real(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=dp), | intent(in) | :: | tau(*) | |||
| real(kind=dp), | intent(inout) | :: | c(ldc,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldc | |||
| real(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
SORMLQ overwrites the general real M-by-N matrix C with SIDE = 'L' SIDE = 'R' TRANS = 'N': Q * C C * Q TRANS = 'T': QT * C C * QT where Q is a real orthogonal matrix defined as the product of k elementary reflectors Q = H(k) . . . H(2) H(1) as returned by SGELQF. Q is of order M if SIDE = 'L' and of order N if SIDE = 'R'.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | side | |||
| character, | intent(in) | :: | trans | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | k | |||
| real(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=sp), | intent(in) | :: | tau(*) | |||
| real(kind=sp), | intent(inout) | :: | c(ldc,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldc | |||
| real(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
ORMQL overwrites the general real M-by-N matrix C with SIDE = 'L' SIDE = 'R' TRANS = 'N': Q * C C * Q TRANS = 'T': QT * C C * QT where Q is a real orthogonal matrix defined as the product of k elementary reflectors Q = H(k) . . . H(2) H(1) as returned by DGEQLF. Q is of order M if SIDE = 'L' and of order N if SIDE = 'R'.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | side | |||
| character, | intent(in) | :: | trans | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | k | |||
| real(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=dp), | intent(in) | :: | tau(*) | |||
| real(kind=dp), | intent(inout) | :: | c(ldc,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldc | |||
| real(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | side | |||
| character, | intent(in) | :: | trans | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | k | |||
| real(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=sp), | intent(in) | :: | tau(*) | |||
| real(kind=sp), | intent(inout) | :: | c(ldc,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldc | |||
| real(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
DORMQL overwrites the general real M-by-N matrix C with SIDE = 'L' SIDE = 'R' TRANS = 'N': Q * C C * Q TRANS = 'T': QT * C C * QT where Q is a real orthogonal matrix defined as the product of k elementary reflectors Q = H(k) . . . H(2) H(1) as returned by DGEQLF. Q is of order M if SIDE = 'L' and of order N if SIDE = 'R'.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | side | |||
| character, | intent(in) | :: | trans | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | k | |||
| real(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=dp), | intent(in) | :: | tau(*) | |||
| real(kind=dp), | intent(inout) | :: | c(ldc,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldc | |||
| real(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
SORMQL overwrites the general real M-by-N matrix C with SIDE = 'L' SIDE = 'R' TRANS = 'N': Q * C C * Q TRANS = 'T': QT * C C * QT where Q is a real orthogonal matrix defined as the product of k elementary reflectors Q = H(k) . . . H(2) H(1) as returned by SGEQLF. Q is of order M if SIDE = 'L' and of order N if SIDE = 'R'.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | side | |||
| character, | intent(in) | :: | trans | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | k | |||
| real(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=sp), | intent(in) | :: | tau(*) | |||
| real(kind=sp), | intent(inout) | :: | c(ldc,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldc | |||
| real(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
ORMQR overwrites the general real M-by-N matrix C with SIDE = 'L' SIDE = 'R' TRANS = 'N': Q * C C * Q TRANS = 'T': QT * C C * QT where Q is a real orthogonal matrix defined as the product of k elementary reflectors Q = H(1) H(2) . . . H(k) as returned by DGEQRF. Q is of order M if SIDE = 'L' and of order N if SIDE = 'R'.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | side | |||
| character, | intent(in) | :: | trans | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | k | |||
| real(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=dp), | intent(in) | :: | tau(*) | |||
| real(kind=dp), | intent(inout) | :: | c(ldc,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldc | |||
| real(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | side | |||
| character, | intent(in) | :: | trans | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | k | |||
| real(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=sp), | intent(in) | :: | tau(*) | |||
| real(kind=sp), | intent(inout) | :: | c(ldc,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldc | |||
| real(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
DORMQR overwrites the general real M-by-N matrix C with SIDE = 'L' SIDE = 'R' TRANS = 'N': Q * C C * Q TRANS = 'T': QT * C C * QT where Q is a real orthogonal matrix defined as the product of k elementary reflectors Q = H(1) H(2) . . . H(k) as returned by DGEQRF. Q is of order M if SIDE = 'L' and of order N if SIDE = 'R'.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | side | |||
| character, | intent(in) | :: | trans | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | k | |||
| real(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=dp), | intent(in) | :: | tau(*) | |||
| real(kind=dp), | intent(inout) | :: | c(ldc,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldc | |||
| real(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
SORMQR overwrites the general real M-by-N matrix C with SIDE = 'L' SIDE = 'R' TRANS = 'N': Q * C C * Q TRANS = 'T': QT * C C * QT where Q is a real orthogonal matrix defined as the product of k elementary reflectors Q = H(1) H(2) . . . H(k) as returned by SGEQRF. Q is of order M if SIDE = 'L' and of order N if SIDE = 'R'.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | side | |||
| character, | intent(in) | :: | trans | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | k | |||
| real(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=sp), | intent(in) | :: | tau(*) | |||
| real(kind=sp), | intent(inout) | :: | c(ldc,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldc | |||
| real(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
ORMRQ overwrites the general real M-by-N matrix C with SIDE = 'L' SIDE = 'R' TRANS = 'N': Q * C C * Q TRANS = 'T': QT * C C * QT where Q is a real orthogonal matrix defined as the product of k elementary reflectors Q = H(1) H(2) . . . H(k) as returned by DGERQF. Q is of order M if SIDE = 'L' and of order N if SIDE = 'R'.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | side | |||
| character, | intent(in) | :: | trans | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | k | |||
| real(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=dp), | intent(in) | :: | tau(*) | |||
| real(kind=dp), | intent(inout) | :: | c(ldc,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldc | |||
| real(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | side | |||
| character, | intent(in) | :: | trans | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | k | |||
| real(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=sp), | intent(in) | :: | tau(*) | |||
| real(kind=sp), | intent(inout) | :: | c(ldc,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldc | |||
| real(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
DORMRQ overwrites the general real M-by-N matrix C with SIDE = 'L' SIDE = 'R' TRANS = 'N': Q * C C * Q TRANS = 'T': QT * C C * QT where Q is a real orthogonal matrix defined as the product of k elementary reflectors Q = H(1) H(2) . . . H(k) as returned by DGERQF. Q is of order M if SIDE = 'L' and of order N if SIDE = 'R'.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | side | |||
| character, | intent(in) | :: | trans | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | k | |||
| real(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=dp), | intent(in) | :: | tau(*) | |||
| real(kind=dp), | intent(inout) | :: | c(ldc,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldc | |||
| real(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
SORMRQ overwrites the general real M-by-N matrix C with SIDE = 'L' SIDE = 'R' TRANS = 'N': Q * C C * Q TRANS = 'T': QT * C C * QT where Q is a real orthogonal matrix defined as the product of k elementary reflectors Q = H(1) H(2) . . . H(k) as returned by SGERQF. Q is of order M if SIDE = 'L' and of order N if SIDE = 'R'.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | side | |||
| character, | intent(in) | :: | trans | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | k | |||
| real(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=sp), | intent(in) | :: | tau(*) | |||
| real(kind=sp), | intent(inout) | :: | c(ldc,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldc | |||
| real(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
ORMRZ overwrites the general real M-by-N matrix C with SIDE = 'L' SIDE = 'R' TRANS = 'N': Q * C C * Q TRANS = 'T': QT * C C * QT where Q is a real orthogonal matrix defined as the product of k elementary reflectors Q = H(1) H(2) . . . H(k) as returned by DTZRZF. Q is of order M if SIDE = 'L' and of order N if SIDE = 'R'.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | side | |||
| character, | intent(in) | :: | trans | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | k | |||
| integer(kind=ilp), | intent(in) | :: | l | |||
| real(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=dp), | intent(in) | :: | tau(*) | |||
| real(kind=dp), | intent(inout) | :: | c(ldc,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldc | |||
| real(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | side | |||
| character, | intent(in) | :: | trans | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | k | |||
| integer(kind=ilp), | intent(in) | :: | l | |||
| real(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=sp), | intent(in) | :: | tau(*) | |||
| real(kind=sp), | intent(inout) | :: | c(ldc,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldc | |||
| real(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
DORMRZ overwrites the general real M-by-N matrix C with SIDE = 'L' SIDE = 'R' TRANS = 'N': Q * C C * Q TRANS = 'T': QT * C C * QT where Q is a real orthogonal matrix defined as the product of k elementary reflectors Q = H(1) H(2) . . . H(k) as returned by DTZRZF. Q is of order M if SIDE = 'L' and of order N if SIDE = 'R'.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | side | |||
| character, | intent(in) | :: | trans | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | k | |||
| integer(kind=ilp), | intent(in) | :: | l | |||
| real(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=dp), | intent(in) | :: | tau(*) | |||
| real(kind=dp), | intent(inout) | :: | c(ldc,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldc | |||
| real(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
SORMRZ overwrites the general real M-by-N matrix C with SIDE = 'L' SIDE = 'R' TRANS = 'N': Q * C C * Q TRANS = 'T': QT * C C * QT where Q is a real orthogonal matrix defined as the product of k elementary reflectors Q = H(1) H(2) . . . H(k) as returned by STZRZF. Q is of order M if SIDE = 'L' and of order N if SIDE = 'R'.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | side | |||
| character, | intent(in) | :: | trans | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | k | |||
| integer(kind=ilp), | intent(in) | :: | l | |||
| real(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=sp), | intent(in) | :: | tau(*) | |||
| real(kind=sp), | intent(inout) | :: | c(ldc,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldc | |||
| real(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
ORMTR overwrites the general real M-by-N matrix C with SIDE = 'L' SIDE = 'R' TRANS = 'N': Q * C C * Q TRANS = 'T': QT * C C * QT where Q is a real orthogonal matrix of order nq, with nq = m if SIDE = 'L' and nq = n if SIDE = 'R'. Q is defined as the product of nq-1 elementary reflectors, as returned by DSYTRD: if UPLO = 'U', Q = H(nq-1) . . . H(2) H(1); if UPLO = 'L', Q = H(1) H(2) . . . H(nq-1).
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | side | |||
| character, | intent(in) | :: | uplo | |||
| character, | intent(in) | :: | trans | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=dp), | intent(in) | :: | tau(*) | |||
| real(kind=dp), | intent(inout) | :: | c(ldc,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldc | |||
| real(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | side | |||
| character, | intent(in) | :: | uplo | |||
| character, | intent(in) | :: | trans | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=sp), | intent(in) | :: | tau(*) | |||
| real(kind=sp), | intent(inout) | :: | c(ldc,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldc | |||
| real(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
DORMTR overwrites the general real M-by-N matrix C with SIDE = 'L' SIDE = 'R' TRANS = 'N': Q * C C * Q TRANS = 'T': QT * C C * QT where Q is a real orthogonal matrix of order nq, with nq = m if SIDE = 'L' and nq = n if SIDE = 'R'. Q is defined as the product of nq-1 elementary reflectors, as returned by DSYTRD: if UPLO = 'U', Q = H(nq-1) . . . H(2) H(1); if UPLO = 'L', Q = H(1) H(2) . . . H(nq-1).
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | side | |||
| character, | intent(in) | :: | uplo | |||
| character, | intent(in) | :: | trans | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=dp), | intent(in) | :: | tau(*) | |||
| real(kind=dp), | intent(inout) | :: | c(ldc,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldc | |||
| real(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
SORMTR overwrites the general real M-by-N matrix C with SIDE = 'L' SIDE = 'R' TRANS = 'N': Q * C C * Q TRANS = 'T': QT * C C * QT where Q is a real orthogonal matrix of order nq, with nq = m if SIDE = 'L' and nq = n if SIDE = 'R'. Q is defined as the product of nq-1 elementary reflectors, as returned by SSYTRD: if UPLO = 'U', Q = H(nq-1) . . . H(2) H(1); if UPLO = 'L', Q = H(1) H(2) . . . H(nq-1).
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | side | |||
| character, | intent(in) | :: | uplo | |||
| character, | intent(in) | :: | trans | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=sp), | intent(in) | :: | tau(*) | |||
| real(kind=sp), | intent(inout) | :: | c(ldc,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldc | |||
| real(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
PBCON estimates the reciprocal of the condition number (in the 1-norm) of a complex Hermitian positive definite band matrix using the Cholesky factorization A = UHU or A = LLH computed by CPBTRF. An estimate is obtained for norm(inv(A)), and the reciprocal of the condition number is computed as RCOND = 1 / (ANORM * norm(inv(A))).
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | kd | |||
| complex(kind=sp), | intent(in) | :: | ab(ldab,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldab | |||
| real(kind=sp), | intent(in) | :: | anorm | |||
| real(kind=sp), | intent(out) | :: | rcond | |||
| complex(kind=sp), | intent(out) | :: | work(*) | |||
| real(kind=sp), | intent(out) | :: | rwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | kd | |||
| real(kind=dp), | intent(in) | :: | ab(ldab,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldab | |||
| real(kind=dp), | intent(in) | :: | anorm | |||
| real(kind=dp), | intent(out) | :: | rcond | |||
| real(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | iwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | kd | |||
| real(kind=sp), | intent(in) | :: | ab(ldab,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldab | |||
| real(kind=sp), | intent(in) | :: | anorm | |||
| real(kind=sp), | intent(out) | :: | rcond | |||
| real(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | iwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | kd | |||
| complex(kind=dp), | intent(in) | :: | ab(ldab,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldab | |||
| real(kind=dp), | intent(in) | :: | anorm | |||
| real(kind=dp), | intent(out) | :: | rcond | |||
| complex(kind=dp), | intent(out) | :: | work(*) | |||
| real(kind=dp), | intent(out) | :: | rwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
CPBCON estimates the reciprocal of the condition number (in the 1-norm) of a complex Hermitian positive definite band matrix using the Cholesky factorization A = UHU or A = LLH computed by CPBTRF. An estimate is obtained for norm(inv(A)), and the reciprocal of the condition number is computed as RCOND = 1 / (ANORM * norm(inv(A))).
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | kd | |||
| complex(kind=sp), | intent(in) | :: | ab(ldab,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldab | |||
| real(kind=sp), | intent(in) | :: | anorm | |||
| real(kind=sp), | intent(out) | :: | rcond | |||
| complex(kind=sp), | intent(out) | :: | work(*) | |||
| real(kind=sp), | intent(out) | :: | rwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
DPBCON estimates the reciprocal of the condition number (in the 1-norm) of a real symmetric positive definite band matrix using the Cholesky factorization A = UTU or A = LLT computed by DPBTRF. An estimate is obtained for norm(inv(A)), and the reciprocal of the condition number is computed as RCOND = 1 / (ANORM * norm(inv(A))).
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | kd | |||
| real(kind=dp), | intent(in) | :: | ab(ldab,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldab | |||
| real(kind=dp), | intent(in) | :: | anorm | |||
| real(kind=dp), | intent(out) | :: | rcond | |||
| real(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | iwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
SPBCON estimates the reciprocal of the condition number (in the 1-norm) of a real symmetric positive definite band matrix using the Cholesky factorization A = UTU or A = LLT computed by SPBTRF. An estimate is obtained for norm(inv(A)), and the reciprocal of the condition number is computed as RCOND = 1 / (ANORM * norm(inv(A))).
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | kd | |||
| real(kind=sp), | intent(in) | :: | ab(ldab,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldab | |||
| real(kind=sp), | intent(in) | :: | anorm | |||
| real(kind=sp), | intent(out) | :: | rcond | |||
| real(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | iwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
ZPBCON estimates the reciprocal of the condition number (in the 1-norm) of a complex Hermitian positive definite band matrix using the Cholesky factorization A = UHU or A = LLH computed by ZPBTRF. An estimate is obtained for norm(inv(A)), and the reciprocal of the condition number is computed as RCOND = 1 / (ANORM * norm(inv(A))).
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | kd | |||
| complex(kind=dp), | intent(in) | :: | ab(ldab,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldab | |||
| real(kind=dp), | intent(in) | :: | anorm | |||
| real(kind=dp), | intent(out) | :: | rcond | |||
| complex(kind=dp), | intent(out) | :: | work(*) | |||
| real(kind=dp), | intent(out) | :: | rwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
PBEQU computes row and column scalings intended to equilibrate a Hermitian positive definite band matrix A and reduce its condition number (with respect to the two-norm). S contains the scale factors, S(i) = 1/sqrt(A(i,i)), chosen so that the scaled matrix B with elements B(i,j) = S(i)A(i,j)S(j) has ones on the diagonal. This choice of S puts the condition number of B within a factor N of the smallest possible condition number over all possible diagonal scalings.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | kd | |||
| complex(kind=sp), | intent(in) | :: | ab(ldab,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldab | |||
| real(kind=sp), | intent(out) | :: | s(*) | |||
| real(kind=sp), | intent(out) | :: | scond | |||
| real(kind=sp), | intent(out) | :: | amax | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | kd | |||
| real(kind=dp), | intent(in) | :: | ab(ldab,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldab | |||
| real(kind=dp), | intent(out) | :: | s(*) | |||
| real(kind=dp), | intent(out) | :: | scond | |||
| real(kind=dp), | intent(out) | :: | amax | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | kd | |||
| real(kind=sp), | intent(in) | :: | ab(ldab,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldab | |||
| real(kind=sp), | intent(out) | :: | s(*) | |||
| real(kind=sp), | intent(out) | :: | scond | |||
| real(kind=sp), | intent(out) | :: | amax | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | kd | |||
| complex(kind=dp), | intent(in) | :: | ab(ldab,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldab | |||
| real(kind=dp), | intent(out) | :: | s(*) | |||
| real(kind=dp), | intent(out) | :: | scond | |||
| real(kind=dp), | intent(out) | :: | amax | |||
| integer(kind=ilp), | intent(out) | :: | info |
CPBEQU computes row and column scalings intended to equilibrate a Hermitian positive definite band matrix A and reduce its condition number (with respect to the two-norm). S contains the scale factors, S(i) = 1/sqrt(A(i,i)), chosen so that the scaled matrix B with elements B(i,j) = S(i)A(i,j)S(j) has ones on the diagonal. This choice of S puts the condition number of B within a factor N of the smallest possible condition number over all possible diagonal scalings.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | kd | |||
| complex(kind=sp), | intent(in) | :: | ab(ldab,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldab | |||
| real(kind=sp), | intent(out) | :: | s(*) | |||
| real(kind=sp), | intent(out) | :: | scond | |||
| real(kind=sp), | intent(out) | :: | amax | |||
| integer(kind=ilp), | intent(out) | :: | info |
DPBEQU computes row and column scalings intended to equilibrate a symmetric positive definite band matrix A and reduce its condition number (with respect to the two-norm). S contains the scale factors, S(i) = 1/sqrt(A(i,i)), chosen so that the scaled matrix B with elements B(i,j) = S(i)A(i,j)S(j) has ones on the diagonal. This choice of S puts the condition number of B within a factor N of the smallest possible condition number over all possible diagonal scalings.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | kd | |||
| real(kind=dp), | intent(in) | :: | ab(ldab,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldab | |||
| real(kind=dp), | intent(out) | :: | s(*) | |||
| real(kind=dp), | intent(out) | :: | scond | |||
| real(kind=dp), | intent(out) | :: | amax | |||
| integer(kind=ilp), | intent(out) | :: | info |
SPBEQU computes row and column scalings intended to equilibrate a symmetric positive definite band matrix A and reduce its condition number (with respect to the two-norm). S contains the scale factors, S(i) = 1/sqrt(A(i,i)), chosen so that the scaled matrix B with elements B(i,j) = S(i)A(i,j)S(j) has ones on the diagonal. This choice of S puts the condition number of B within a factor N of the smallest possible condition number over all possible diagonal scalings.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | kd | |||
| real(kind=sp), | intent(in) | :: | ab(ldab,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldab | |||
| real(kind=sp), | intent(out) | :: | s(*) | |||
| real(kind=sp), | intent(out) | :: | scond | |||
| real(kind=sp), | intent(out) | :: | amax | |||
| integer(kind=ilp), | intent(out) | :: | info |
ZPBEQU computes row and column scalings intended to equilibrate a Hermitian positive definite band matrix A and reduce its condition number (with respect to the two-norm). S contains the scale factors, S(i) = 1/sqrt(A(i,i)), chosen so that the scaled matrix B with elements B(i,j) = S(i)A(i,j)S(j) has ones on the diagonal. This choice of S puts the condition number of B within a factor N of the smallest possible condition number over all possible diagonal scalings.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | kd | |||
| complex(kind=dp), | intent(in) | :: | ab(ldab,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldab | |||
| real(kind=dp), | intent(out) | :: | s(*) | |||
| real(kind=dp), | intent(out) | :: | scond | |||
| real(kind=dp), | intent(out) | :: | amax | |||
| integer(kind=ilp), | intent(out) | :: | info |
PBRFS improves the computed solution to a system of linear equations when the coefficient matrix is Hermitian positive definite and banded, and provides error bounds and backward error estimates for the solution.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | kd | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| complex(kind=sp), | intent(in) | :: | ab(ldab,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldab | |||
| complex(kind=sp), | intent(in) | :: | afb(ldafb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldafb | |||
| complex(kind=sp), | intent(in) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| complex(kind=sp), | intent(inout) | :: | x(ldx,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldx | |||
| real(kind=sp), | intent(out) | :: | ferr(*) | |||
| real(kind=sp), | intent(out) | :: | berr(*) | |||
| complex(kind=sp), | intent(out) | :: | work(*) | |||
| real(kind=sp), | intent(out) | :: | rwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | kd | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| real(kind=dp), | intent(in) | :: | ab(ldab,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldab | |||
| real(kind=dp), | intent(in) | :: | afb(ldafb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldafb | |||
| real(kind=dp), | intent(in) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| real(kind=dp), | intent(inout) | :: | x(ldx,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldx | |||
| real(kind=dp), | intent(out) | :: | ferr(*) | |||
| real(kind=dp), | intent(out) | :: | berr(*) | |||
| real(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | iwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | kd | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| real(kind=sp), | intent(in) | :: | ab(ldab,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldab | |||
| real(kind=sp), | intent(in) | :: | afb(ldafb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldafb | |||
| real(kind=sp), | intent(in) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| real(kind=sp), | intent(inout) | :: | x(ldx,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldx | |||
| real(kind=sp), | intent(out) | :: | ferr(*) | |||
| real(kind=sp), | intent(out) | :: | berr(*) | |||
| real(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | iwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | kd | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| complex(kind=dp), | intent(in) | :: | ab(ldab,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldab | |||
| complex(kind=dp), | intent(in) | :: | afb(ldafb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldafb | |||
| complex(kind=dp), | intent(in) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| complex(kind=dp), | intent(inout) | :: | x(ldx,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldx | |||
| real(kind=dp), | intent(out) | :: | ferr(*) | |||
| real(kind=dp), | intent(out) | :: | berr(*) | |||
| complex(kind=dp), | intent(out) | :: | work(*) | |||
| real(kind=dp), | intent(out) | :: | rwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
CPBRFS improves the computed solution to a system of linear equations when the coefficient matrix is Hermitian positive definite and banded, and provides error bounds and backward error estimates for the solution.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | kd | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| complex(kind=sp), | intent(in) | :: | ab(ldab,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldab | |||
| complex(kind=sp), | intent(in) | :: | afb(ldafb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldafb | |||
| complex(kind=sp), | intent(in) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| complex(kind=sp), | intent(inout) | :: | x(ldx,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldx | |||
| real(kind=sp), | intent(out) | :: | ferr(*) | |||
| real(kind=sp), | intent(out) | :: | berr(*) | |||
| complex(kind=sp), | intent(out) | :: | work(*) | |||
| real(kind=sp), | intent(out) | :: | rwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
DPBRFS improves the computed solution to a system of linear equations when the coefficient matrix is symmetric positive definite and banded, and provides error bounds and backward error estimates for the solution.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | kd | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| real(kind=dp), | intent(in) | :: | ab(ldab,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldab | |||
| real(kind=dp), | intent(in) | :: | afb(ldafb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldafb | |||
| real(kind=dp), | intent(in) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| real(kind=dp), | intent(inout) | :: | x(ldx,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldx | |||
| real(kind=dp), | intent(out) | :: | ferr(*) | |||
| real(kind=dp), | intent(out) | :: | berr(*) | |||
| real(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | iwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
SPBRFS improves the computed solution to a system of linear equations when the coefficient matrix is symmetric positive definite and banded, and provides error bounds and backward error estimates for the solution.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | kd | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| real(kind=sp), | intent(in) | :: | ab(ldab,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldab | |||
| real(kind=sp), | intent(in) | :: | afb(ldafb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldafb | |||
| real(kind=sp), | intent(in) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| real(kind=sp), | intent(inout) | :: | x(ldx,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldx | |||
| real(kind=sp), | intent(out) | :: | ferr(*) | |||
| real(kind=sp), | intent(out) | :: | berr(*) | |||
| real(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | iwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
ZPBRFS improves the computed solution to a system of linear equations when the coefficient matrix is Hermitian positive definite and banded, and provides error bounds and backward error estimates for the solution.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | kd | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| complex(kind=dp), | intent(in) | :: | ab(ldab,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldab | |||
| complex(kind=dp), | intent(in) | :: | afb(ldafb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldafb | |||
| complex(kind=dp), | intent(in) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| complex(kind=dp), | intent(inout) | :: | x(ldx,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldx | |||
| real(kind=dp), | intent(out) | :: | ferr(*) | |||
| real(kind=dp), | intent(out) | :: | berr(*) | |||
| complex(kind=dp), | intent(out) | :: | work(*) | |||
| real(kind=dp), | intent(out) | :: | rwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
PBSTF computes a split Cholesky factorization of a complex Hermitian positive definite band matrix A. This routine is designed to be used in conjunction with CHBGST. The factorization has the form A = S*HS where S is a band matrix of the same bandwidth as A and the following structure: S = ( U ) ( M L ) where U is upper triangular of order m = (n+kd)/2, and L is lower triangular of order n-m.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | kd | |||
| complex(kind=sp), | intent(inout) | :: | ab(ldab,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldab | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | kd | |||
| real(kind=dp), | intent(inout) | :: | ab(ldab,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldab | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | kd | |||
| real(kind=sp), | intent(inout) | :: | ab(ldab,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldab | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | kd | |||
| complex(kind=dp), | intent(inout) | :: | ab(ldab,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldab | |||
| integer(kind=ilp), | intent(out) | :: | info |
CPBSTF computes a split Cholesky factorization of a complex Hermitian positive definite band matrix A. This routine is designed to be used in conjunction with CHBGST. The factorization has the form A = S*HS where S is a band matrix of the same bandwidth as A and the following structure: S = ( U ) ( M L ) where U is upper triangular of order m = (n+kd)/2, and L is lower triangular of order n-m.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | kd | |||
| complex(kind=sp), | intent(inout) | :: | ab(ldab,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldab | |||
| integer(kind=ilp), | intent(out) | :: | info |
DPBSTF computes a split Cholesky factorization of a real symmetric positive definite band matrix A. This routine is designed to be used in conjunction with DSBGST. The factorization has the form A = S*TS where S is a band matrix of the same bandwidth as A and the following structure: S = ( U ) ( M L ) where U is upper triangular of order m = (n+kd)/2, and L is lower triangular of order n-m.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | kd | |||
| real(kind=dp), | intent(inout) | :: | ab(ldab,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldab | |||
| integer(kind=ilp), | intent(out) | :: | info |
SPBSTF computes a split Cholesky factorization of a real symmetric positive definite band matrix A. This routine is designed to be used in conjunction with SSBGST. The factorization has the form A = S*TS where S is a band matrix of the same bandwidth as A and the following structure: S = ( U ) ( M L ) where U is upper triangular of order m = (n+kd)/2, and L is lower triangular of order n-m.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | kd | |||
| real(kind=sp), | intent(inout) | :: | ab(ldab,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldab | |||
| integer(kind=ilp), | intent(out) | :: | info |
ZPBSTF computes a split Cholesky factorization of a complex Hermitian positive definite band matrix A. This routine is designed to be used in conjunction with ZHBGST. The factorization has the form A = S*HS where S is a band matrix of the same bandwidth as A and the following structure: S = ( U ) ( M L ) where U is upper triangular of order m = (n+kd)/2, and L is lower triangular of order n-m.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | kd | |||
| complex(kind=dp), | intent(inout) | :: | ab(ldab,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldab | |||
| integer(kind=ilp), | intent(out) | :: | info |
PBSV computes the solution to a complex system of linear equations A * X = B, where A is an N-by-N Hermitian positive definite band matrix and X and B are N-by-NRHS matrices. The Cholesky decomposition is used to factor A as A = UH * U, if UPLO = 'U', or A = L * LH, if UPLO = 'L', where U is an upper triangular band matrix, and L is a lower triangular band matrix, with the same number of superdiagonals or subdiagonals as A. The factored form of A is then used to solve the system of equations A * X = B.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | kd | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| complex(kind=sp), | intent(inout) | :: | ab(ldab,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldab | |||
| complex(kind=sp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | kd | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| real(kind=dp), | intent(inout) | :: | ab(ldab,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldab | |||
| real(kind=dp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | kd | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| real(kind=sp), | intent(inout) | :: | ab(ldab,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldab | |||
| real(kind=sp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | kd | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| complex(kind=dp), | intent(inout) | :: | ab(ldab,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldab | |||
| complex(kind=dp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| integer(kind=ilp), | intent(out) | :: | info |
CPBSV computes the solution to a complex system of linear equations A * X = B, where A is an N-by-N Hermitian positive definite band matrix and X and B are N-by-NRHS matrices. The Cholesky decomposition is used to factor A as A = UH * U, if UPLO = 'U', or A = L * LH, if UPLO = 'L', where U is an upper triangular band matrix, and L is a lower triangular band matrix, with the same number of superdiagonals or subdiagonals as A. The factored form of A is then used to solve the system of equations A * X = B.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | kd | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| complex(kind=sp), | intent(inout) | :: | ab(ldab,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldab | |||
| complex(kind=sp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| integer(kind=ilp), | intent(out) | :: | info |
DPBSV computes the solution to a real system of linear equations A * X = B, where A is an N-by-N symmetric positive definite band matrix and X and B are N-by-NRHS matrices. The Cholesky decomposition is used to factor A as A = UT * U, if UPLO = 'U', or A = L * LT, if UPLO = 'L', where U is an upper triangular band matrix, and L is a lower triangular band matrix, with the same number of superdiagonals or subdiagonals as A. The factored form of A is then used to solve the system of equations A * X = B.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | kd | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| real(kind=dp), | intent(inout) | :: | ab(ldab,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldab | |||
| real(kind=dp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| integer(kind=ilp), | intent(out) | :: | info |
SPBSV computes the solution to a real system of linear equations A * X = B, where A is an N-by-N symmetric positive definite band matrix and X and B are N-by-NRHS matrices. The Cholesky decomposition is used to factor A as A = UT * U, if UPLO = 'U', or A = L * LT, if UPLO = 'L', where U is an upper triangular band matrix, and L is a lower triangular band matrix, with the same number of superdiagonals or subdiagonals as A. The factored form of A is then used to solve the system of equations A * X = B.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | kd | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| real(kind=sp), | intent(inout) | :: | ab(ldab,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldab | |||
| real(kind=sp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| integer(kind=ilp), | intent(out) | :: | info |
ZPBSV computes the solution to a complex system of linear equations A * X = B, where A is an N-by-N Hermitian positive definite band matrix and X and B are N-by-NRHS matrices. The Cholesky decomposition is used to factor A as A = UH * U, if UPLO = 'U', or A = L * LH, if UPLO = 'L', where U is an upper triangular band matrix, and L is a lower triangular band matrix, with the same number of superdiagonals or subdiagonals as A. The factored form of A is then used to solve the system of equations A * X = B.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | kd | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| complex(kind=dp), | intent(inout) | :: | ab(ldab,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldab | |||
| complex(kind=dp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| integer(kind=ilp), | intent(out) | :: | info |
PBTRF computes the Cholesky factorization of a complex Hermitian positive definite band matrix A. The factorization has the form A = UH * U, if UPLO = 'U', or A = L * LH, if UPLO = 'L', where U is an upper triangular matrix and L is lower triangular.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | kd | |||
| complex(kind=sp), | intent(inout) | :: | ab(ldab,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldab | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | kd | |||
| real(kind=dp), | intent(inout) | :: | ab(ldab,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldab | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | kd | |||
| real(kind=sp), | intent(inout) | :: | ab(ldab,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldab | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | kd | |||
| complex(kind=dp), | intent(inout) | :: | ab(ldab,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldab | |||
| integer(kind=ilp), | intent(out) | :: | info |
CPBTRF computes the Cholesky factorization of a complex Hermitian positive definite band matrix A. The factorization has the form A = UH * U, if UPLO = 'U', or A = L * LH, if UPLO = 'L', where U is an upper triangular matrix and L is lower triangular.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | kd | |||
| complex(kind=sp), | intent(inout) | :: | ab(ldab,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldab | |||
| integer(kind=ilp), | intent(out) | :: | info |
DPBTRF computes the Cholesky factorization of a real symmetric positive definite band matrix A. The factorization has the form A = UT * U, if UPLO = 'U', or A = L * LT, if UPLO = 'L', where U is an upper triangular matrix and L is lower triangular.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | kd | |||
| real(kind=dp), | intent(inout) | :: | ab(ldab,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldab | |||
| integer(kind=ilp), | intent(out) | :: | info |
SPBTRF computes the Cholesky factorization of a real symmetric positive definite band matrix A. The factorization has the form A = UT * U, if UPLO = 'U', or A = L * LT, if UPLO = 'L', where U is an upper triangular matrix and L is lower triangular.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | kd | |||
| real(kind=sp), | intent(inout) | :: | ab(ldab,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldab | |||
| integer(kind=ilp), | intent(out) | :: | info |
ZPBTRF computes the Cholesky factorization of a complex Hermitian positive definite band matrix A. The factorization has the form A = UH * U, if UPLO = 'U', or A = L * LH, if UPLO = 'L', where U is an upper triangular matrix and L is lower triangular.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | kd | |||
| complex(kind=dp), | intent(inout) | :: | ab(ldab,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldab | |||
| integer(kind=ilp), | intent(out) | :: | info |
PBTRS solves a system of linear equations AX = B with a Hermitian positive definite band matrix A using the Cholesky factorization A = UHU or A = LL*H computed by CPBTRF.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | kd | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| complex(kind=sp), | intent(in) | :: | ab(ldab,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldab | |||
| complex(kind=sp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | kd | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| real(kind=dp), | intent(in) | :: | ab(ldab,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldab | |||
| real(kind=dp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | kd | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| real(kind=sp), | intent(in) | :: | ab(ldab,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldab | |||
| real(kind=sp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | kd | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| complex(kind=dp), | intent(in) | :: | ab(ldab,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldab | |||
| complex(kind=dp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| integer(kind=ilp), | intent(out) | :: | info |
CPBTRS solves a system of linear equations AX = B with a Hermitian positive definite band matrix A using the Cholesky factorization A = UHU or A = LL*H computed by CPBTRF.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | kd | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| complex(kind=sp), | intent(in) | :: | ab(ldab,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldab | |||
| complex(kind=sp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| integer(kind=ilp), | intent(out) | :: | info |
DPBTRS solves a system of linear equations AX = B with a symmetric positive definite band matrix A using the Cholesky factorization A = UTU or A = LL*T computed by DPBTRF.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | kd | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| real(kind=dp), | intent(in) | :: | ab(ldab,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldab | |||
| real(kind=dp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| integer(kind=ilp), | intent(out) | :: | info |
SPBTRS solves a system of linear equations AX = B with a symmetric positive definite band matrix A using the Cholesky factorization A = UTU or A = LL*T computed by SPBTRF.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | kd | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| real(kind=sp), | intent(in) | :: | ab(ldab,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldab | |||
| real(kind=sp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| integer(kind=ilp), | intent(out) | :: | info |
ZPBTRS solves a system of linear equations AX = B with a Hermitian positive definite band matrix A using the Cholesky factorization A = UH U or A = LL*H computed by ZPBTRF.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | kd | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| complex(kind=dp), | intent(in) | :: | ab(ldab,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldab | |||
| complex(kind=dp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| integer(kind=ilp), | intent(out) | :: | info |
PFTRF computes the Cholesky factorization of a complex Hermitian positive definite matrix A. The factorization has the form A = UH * U, if UPLO = 'U', or A = L * LH, if UPLO = 'L', where U is an upper triangular matrix and L is lower triangular. This is the block version of the algorithm, calling Level 3 BLAS.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | transr | |||
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=sp), | intent(inout) | :: | a(0:*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | transr | |||
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=dp), | intent(inout) | :: | a(0:*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | transr | |||
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=sp), | intent(inout) | :: | a(0:*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | transr | |||
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=dp), | intent(inout) | :: | a(0:*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
CPFTRF computes the Cholesky factorization of a complex Hermitian positive definite matrix A. The factorization has the form A = UH * U, if UPLO = 'U', or A = L * LH, if UPLO = 'L', where U is an upper triangular matrix and L is lower triangular. This is the block version of the algorithm, calling Level 3 BLAS.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | transr | |||
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=sp), | intent(inout) | :: | a(0:*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
DPFTRF computes the Cholesky factorization of a real symmetric positive definite matrix A. The factorization has the form A = UT * U, if UPLO = 'U', or A = L * LT, if UPLO = 'L', where U is an upper triangular matrix and L is lower triangular. This is the block version of the algorithm, calling Level 3 BLAS.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | transr | |||
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=dp), | intent(inout) | :: | a(0:*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
SPFTRF computes the Cholesky factorization of a real symmetric positive definite matrix A. The factorization has the form A = UT * U, if UPLO = 'U', or A = L * LT, if UPLO = 'L', where U is an upper triangular matrix and L is lower triangular. This is the block version of the algorithm, calling Level 3 BLAS.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | transr | |||
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=sp), | intent(inout) | :: | a(0:*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
ZPFTRF computes the Cholesky factorization of a complex Hermitian positive definite matrix A. The factorization has the form A = UH * U, if UPLO = 'U', or A = L * LH, if UPLO = 'L', where U is an upper triangular matrix and L is lower triangular. This is the block version of the algorithm, calling Level 3 BLAS.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | transr | |||
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=dp), | intent(inout) | :: | a(0:*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
PFTRI computes the inverse of a complex Hermitian positive definite matrix A using the Cholesky factorization A = UHU or A = LLH computed by CPFTRF.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | transr | |||
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=sp), | intent(inout) | :: | a(0:*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | transr | |||
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=dp), | intent(inout) | :: | a(0:*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | transr | |||
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=sp), | intent(inout) | :: | a(0:*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | transr | |||
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=dp), | intent(inout) | :: | a(0:*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
CPFTRI computes the inverse of a complex Hermitian positive definite matrix A using the Cholesky factorization A = UHU or A = LLH computed by CPFTRF.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | transr | |||
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=sp), | intent(inout) | :: | a(0:*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
DPFTRI computes the inverse of a (real) symmetric positive definite matrix A using the Cholesky factorization A = UTU or A = LLT computed by DPFTRF.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | transr | |||
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=dp), | intent(inout) | :: | a(0:*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
SPFTRI computes the inverse of a real (symmetric) positive definite matrix A using the Cholesky factorization A = UTU or A = LLT computed by SPFTRF.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | transr | |||
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=sp), | intent(inout) | :: | a(0:*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
ZPFTRI computes the inverse of a complex Hermitian positive definite matrix A using the Cholesky factorization A = UHU or A = LLH computed by ZPFTRF.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | transr | |||
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=dp), | intent(inout) | :: | a(0:*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
PFTRS solves a system of linear equations AX = B with a Hermitian positive definite matrix A using the Cholesky factorization A = UHU or A = LL*H computed by CPFTRF.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | transr | |||
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| complex(kind=sp), | intent(in) | :: | a(0:*) | |||
| complex(kind=sp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | transr | |||
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| real(kind=dp), | intent(in) | :: | a(0:*) | |||
| real(kind=dp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | transr | |||
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| real(kind=sp), | intent(in) | :: | a(0:*) | |||
| real(kind=sp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | transr | |||
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| complex(kind=dp), | intent(in) | :: | a(0:*) | |||
| complex(kind=dp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| integer(kind=ilp), | intent(out) | :: | info |
CPFTRS solves a system of linear equations AX = B with a Hermitian positive definite matrix A using the Cholesky factorization A = UHU or A = LL*H computed by CPFTRF.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | transr | |||
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| complex(kind=sp), | intent(in) | :: | a(0:*) | |||
| complex(kind=sp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| integer(kind=ilp), | intent(out) | :: | info |
DPFTRS solves a system of linear equations AX = B with a symmetric positive definite matrix A using the Cholesky factorization A = UTU or A = LL*T computed by DPFTRF.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | transr | |||
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| real(kind=dp), | intent(in) | :: | a(0:*) | |||
| real(kind=dp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| integer(kind=ilp), | intent(out) | :: | info |
SPFTRS solves a system of linear equations AX = B with a symmetric positive definite matrix A using the Cholesky factorization A = UTU or A = LL*T computed by SPFTRF.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | transr | |||
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| real(kind=sp), | intent(in) | :: | a(0:*) | |||
| real(kind=sp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| integer(kind=ilp), | intent(out) | :: | info |
ZPFTRS solves a system of linear equations AX = B with a Hermitian positive definite matrix A using the Cholesky factorization A = UHU or A = LL*H computed by ZPFTRF.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | transr | |||
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| complex(kind=dp), | intent(in) | :: | a(0:*) | |||
| complex(kind=dp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| integer(kind=ilp), | intent(out) | :: | info |
POCON estimates the reciprocal of the condition number (in the 1-norm) of a complex Hermitian positive definite matrix using the Cholesky factorization A = UHU or A = LLH computed by CPOTRF. An estimate is obtained for norm(inv(A)), and the reciprocal of the condition number is computed as RCOND = 1 / (ANORM * norm(inv(A))).
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=sp), | intent(in) | :: | anorm | |||
| real(kind=sp), | intent(out) | :: | rcond | |||
| complex(kind=sp), | intent(out) | :: | work(*) | |||
| real(kind=sp), | intent(out) | :: | rwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=dp), | intent(in) | :: | anorm | |||
| real(kind=dp), | intent(out) | :: | rcond | |||
| real(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | iwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=sp), | intent(in) | :: | anorm | |||
| real(kind=sp), | intent(out) | :: | rcond | |||
| real(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | iwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=dp), | intent(in) | :: | anorm | |||
| real(kind=dp), | intent(out) | :: | rcond | |||
| complex(kind=dp), | intent(out) | :: | work(*) | |||
| real(kind=dp), | intent(out) | :: | rwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
CPOCON estimates the reciprocal of the condition number (in the 1-norm) of a complex Hermitian positive definite matrix using the Cholesky factorization A = UHU or A = LLH computed by CPOTRF. An estimate is obtained for norm(inv(A)), and the reciprocal of the condition number is computed as RCOND = 1 / (ANORM * norm(inv(A))).
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=sp), | intent(in) | :: | anorm | |||
| real(kind=sp), | intent(out) | :: | rcond | |||
| complex(kind=sp), | intent(out) | :: | work(*) | |||
| real(kind=sp), | intent(out) | :: | rwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
DPOCON estimates the reciprocal of the condition number (in the 1-norm) of a real symmetric positive definite matrix using the Cholesky factorization A = UTU or A = LLT computed by DPOTRF. An estimate is obtained for norm(inv(A)), and the reciprocal of the condition number is computed as RCOND = 1 / (ANORM * norm(inv(A))).
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=dp), | intent(in) | :: | anorm | |||
| real(kind=dp), | intent(out) | :: | rcond | |||
| real(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | iwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
SPOCON estimates the reciprocal of the condition number (in the 1-norm) of a real symmetric positive definite matrix using the Cholesky factorization A = UTU or A = LLT computed by SPOTRF. An estimate is obtained for norm(inv(A)), and the reciprocal of the condition number is computed as RCOND = 1 / (ANORM * norm(inv(A))).
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=sp), | intent(in) | :: | anorm | |||
| real(kind=sp), | intent(out) | :: | rcond | |||
| real(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | iwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
ZPOCON estimates the reciprocal of the condition number (in the 1-norm) of a complex Hermitian positive definite matrix using the Cholesky factorization A = UHU or A = LLH computed by ZPOTRF. An estimate is obtained for norm(inv(A)), and the reciprocal of the condition number is computed as RCOND = 1 / (ANORM * norm(inv(A))).
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=dp), | intent(in) | :: | anorm | |||
| real(kind=dp), | intent(out) | :: | rcond | |||
| complex(kind=dp), | intent(out) | :: | work(*) | |||
| real(kind=dp), | intent(out) | :: | rwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
POEQU computes row and column scalings intended to equilibrate a Hermitian positive definite matrix A and reduce its condition number (with respect to the two-norm). S contains the scale factors, S(i) = 1/sqrt(A(i,i)), chosen so that the scaled matrix B with elements B(i,j) = S(i)A(i,j)S(j) has ones on the diagonal. This choice of S puts the condition number of B within a factor N of the smallest possible condition number over all possible diagonal scalings.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=sp), | intent(in) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=sp), | intent(out) | :: | s(*) | |||
| real(kind=sp), | intent(out) | :: | scond | |||
| real(kind=sp), | intent(out) | :: | amax | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=dp), | intent(in) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=dp), | intent(out) | :: | s(*) | |||
| real(kind=dp), | intent(out) | :: | scond | |||
| real(kind=dp), | intent(out) | :: | amax | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=sp), | intent(in) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=sp), | intent(out) | :: | s(*) | |||
| real(kind=sp), | intent(out) | :: | scond | |||
| real(kind=sp), | intent(out) | :: | amax | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=dp), | intent(in) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=dp), | intent(out) | :: | s(*) | |||
| real(kind=dp), | intent(out) | :: | scond | |||
| real(kind=dp), | intent(out) | :: | amax | |||
| integer(kind=ilp), | intent(out) | :: | info |
CPOEQU computes row and column scalings intended to equilibrate a Hermitian positive definite matrix A and reduce its condition number (with respect to the two-norm). S contains the scale factors, S(i) = 1/sqrt(A(i,i)), chosen so that the scaled matrix B with elements B(i,j) = S(i)A(i,j)S(j) has ones on the diagonal. This choice of S puts the condition number of B within a factor N of the smallest possible condition number over all possible diagonal scalings.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=sp), | intent(in) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=sp), | intent(out) | :: | s(*) | |||
| real(kind=sp), | intent(out) | :: | scond | |||
| real(kind=sp), | intent(out) | :: | amax | |||
| integer(kind=ilp), | intent(out) | :: | info |
DPOEQU computes row and column scalings intended to equilibrate a symmetric positive definite matrix A and reduce its condition number (with respect to the two-norm). S contains the scale factors, S(i) = 1/sqrt(A(i,i)), chosen so that the scaled matrix B with elements B(i,j) = S(i)A(i,j)S(j) has ones on the diagonal. This choice of S puts the condition number of B within a factor N of the smallest possible condition number over all possible diagonal scalings.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=dp), | intent(in) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=dp), | intent(out) | :: | s(*) | |||
| real(kind=dp), | intent(out) | :: | scond | |||
| real(kind=dp), | intent(out) | :: | amax | |||
| integer(kind=ilp), | intent(out) | :: | info |
SPOEQU computes row and column scalings intended to equilibrate a symmetric positive definite matrix A and reduce its condition number (with respect to the two-norm). S contains the scale factors, S(i) = 1/sqrt(A(i,i)), chosen so that the scaled matrix B with elements B(i,j) = S(i)A(i,j)S(j) has ones on the diagonal. This choice of S puts the condition number of B within a factor N of the smallest possible condition number over all possible diagonal scalings.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=sp), | intent(in) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=sp), | intent(out) | :: | s(*) | |||
| real(kind=sp), | intent(out) | :: | scond | |||
| real(kind=sp), | intent(out) | :: | amax | |||
| integer(kind=ilp), | intent(out) | :: | info |
ZPOEQU computes row and column scalings intended to equilibrate a Hermitian positive definite matrix A and reduce its condition number (with respect to the two-norm). S contains the scale factors, S(i) = 1/sqrt(A(i,i)), chosen so that the scaled matrix B with elements B(i,j) = S(i)A(i,j)S(j) has ones on the diagonal. This choice of S puts the condition number of B within a factor N of the smallest possible condition number over all possible diagonal scalings.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=dp), | intent(in) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=dp), | intent(out) | :: | s(*) | |||
| real(kind=dp), | intent(out) | :: | scond | |||
| real(kind=dp), | intent(out) | :: | amax | |||
| integer(kind=ilp), | intent(out) | :: | info |
POEQUB computes row and column scalings intended to equilibrate a Hermitian positive definite matrix A and reduce its condition number (with respect to the two-norm). S contains the scale factors, S(i) = 1/sqrt(A(i,i)), chosen so that the scaled matrix B with elements B(i,j) = S(i)A(i,j)S(j) has ones on the diagonal. This choice of S puts the condition number of B within a factor N of the smallest possible condition number over all possible diagonal scalings. This routine differs from CPOEQU by restricting the scaling factors to a power of the radix. Barring over- and underflow, scaling by these factors introduces no additional rounding errors. However, the scaled diagonal entries are no longer approximately 1 but lie between sqrt(radix) and 1/sqrt(radix).
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=sp), | intent(in) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=sp), | intent(out) | :: | s(*) | |||
| real(kind=sp), | intent(out) | :: | scond | |||
| real(kind=sp), | intent(out) | :: | amax | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=dp), | intent(in) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=dp), | intent(out) | :: | s(*) | |||
| real(kind=dp), | intent(out) | :: | scond | |||
| real(kind=dp), | intent(out) | :: | amax | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=sp), | intent(in) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=sp), | intent(out) | :: | s(*) | |||
| real(kind=sp), | intent(out) | :: | scond | |||
| real(kind=sp), | intent(out) | :: | amax | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=dp), | intent(in) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=dp), | intent(out) | :: | s(*) | |||
| real(kind=dp), | intent(out) | :: | scond | |||
| real(kind=dp), | intent(out) | :: | amax | |||
| integer(kind=ilp), | intent(out) | :: | info |
CPOEQUB computes row and column scalings intended to equilibrate a Hermitian positive definite matrix A and reduce its condition number (with respect to the two-norm). S contains the scale factors, S(i) = 1/sqrt(A(i,i)), chosen so that the scaled matrix B with elements B(i,j) = S(i)A(i,j)S(j) has ones on the diagonal. This choice of S puts the condition number of B within a factor N of the smallest possible condition number over all possible diagonal scalings. This routine differs from CPOEQU by restricting the scaling factors to a power of the radix. Barring over- and underflow, scaling by these factors introduces no additional rounding errors. However, the scaled diagonal entries are no longer approximately 1 but lie between sqrt(radix) and 1/sqrt(radix).
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=sp), | intent(in) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=sp), | intent(out) | :: | s(*) | |||
| real(kind=sp), | intent(out) | :: | scond | |||
| real(kind=sp), | intent(out) | :: | amax | |||
| integer(kind=ilp), | intent(out) | :: | info |
DPOEQUB computes row and column scalings intended to equilibrate a symmetric positive definite matrix A and reduce its condition number (with respect to the two-norm). S contains the scale factors, S(i) = 1/sqrt(A(i,i)), chosen so that the scaled matrix B with elements B(i,j) = S(i)A(i,j)S(j) has ones on the diagonal. This choice of S puts the condition number of B within a factor N of the smallest possible condition number over all possible diagonal scalings. This routine differs from DPOEQU by restricting the scaling factors to a power of the radix. Barring over- and underflow, scaling by these factors introduces no additional rounding errors. However, the scaled diagonal entries are no longer approximately 1 but lie between sqrt(radix) and 1/sqrt(radix).
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=dp), | intent(in) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=dp), | intent(out) | :: | s(*) | |||
| real(kind=dp), | intent(out) | :: | scond | |||
| real(kind=dp), | intent(out) | :: | amax | |||
| integer(kind=ilp), | intent(out) | :: | info |
SPOEQUB computes row and column scalings intended to equilibrate a symmetric positive definite matrix A and reduce its condition number (with respect to the two-norm). S contains the scale factors, S(i) = 1/sqrt(A(i,i)), chosen so that the scaled matrix B with elements B(i,j) = S(i)A(i,j)S(j) has ones on the diagonal. This choice of S puts the condition number of B within a factor N of the smallest possible condition number over all possible diagonal scalings. This routine differs from SPOEQU by restricting the scaling factors to a power of the radix. Barring over- and underflow, scaling by these factors introduces no additional rounding errors. However, the scaled diagonal entries are no longer approximately 1 but lie between sqrt(radix) and 1/sqrt(radix).
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=sp), | intent(in) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=sp), | intent(out) | :: | s(*) | |||
| real(kind=sp), | intent(out) | :: | scond | |||
| real(kind=sp), | intent(out) | :: | amax | |||
| integer(kind=ilp), | intent(out) | :: | info |
ZPOEQUB computes row and column scalings intended to equilibrate a Hermitian positive definite matrix A and reduce its condition number (with respect to the two-norm). S contains the scale factors, S(i) = 1/sqrt(A(i,i)), chosen so that the scaled matrix B with elements B(i,j) = S(i)A(i,j)S(j) has ones on the diagonal. This choice of S puts the condition number of B within a factor N of the smallest possible condition number over all possible diagonal scalings. This routine differs from ZPOEQU by restricting the scaling factors to a power of the radix. Barring over- and underflow, scaling by these factors introduces no additional rounding errors. However, the scaled diagonal entries are no longer approximately 1 but lie between sqrt(radix) and 1/sqrt(radix).
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=dp), | intent(in) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=dp), | intent(out) | :: | s(*) | |||
| real(kind=dp), | intent(out) | :: | scond | |||
| real(kind=dp), | intent(out) | :: | amax | |||
| integer(kind=ilp), | intent(out) | :: | info |
PORFS improves the computed solution to a system of linear equations when the coefficient matrix is Hermitian positive definite, and provides error bounds and backward error estimates for the solution.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| complex(kind=sp), | intent(in) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=sp), | intent(in) | :: | af(ldaf,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldaf | |||
| complex(kind=sp), | intent(in) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| complex(kind=sp), | intent(inout) | :: | x(ldx,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldx | |||
| real(kind=sp), | intent(out) | :: | ferr(*) | |||
| real(kind=sp), | intent(out) | :: | berr(*) | |||
| complex(kind=sp), | intent(out) | :: | work(*) | |||
| real(kind=sp), | intent(out) | :: | rwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| real(kind=dp), | intent(in) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=dp), | intent(in) | :: | af(ldaf,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldaf | |||
| real(kind=dp), | intent(in) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| real(kind=dp), | intent(inout) | :: | x(ldx,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldx | |||
| real(kind=dp), | intent(out) | :: | ferr(*) | |||
| real(kind=dp), | intent(out) | :: | berr(*) | |||
| real(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | iwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| real(kind=sp), | intent(in) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=sp), | intent(in) | :: | af(ldaf,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldaf | |||
| real(kind=sp), | intent(in) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| real(kind=sp), | intent(inout) | :: | x(ldx,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldx | |||
| real(kind=sp), | intent(out) | :: | ferr(*) | |||
| real(kind=sp), | intent(out) | :: | berr(*) | |||
| real(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | iwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| complex(kind=dp), | intent(in) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=dp), | intent(in) | :: | af(ldaf,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldaf | |||
| complex(kind=dp), | intent(in) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| complex(kind=dp), | intent(inout) | :: | x(ldx,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldx | |||
| real(kind=dp), | intent(out) | :: | ferr(*) | |||
| real(kind=dp), | intent(out) | :: | berr(*) | |||
| complex(kind=dp), | intent(out) | :: | work(*) | |||
| real(kind=dp), | intent(out) | :: | rwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
CPORFS improves the computed solution to a system of linear equations when the coefficient matrix is Hermitian positive definite, and provides error bounds and backward error estimates for the solution.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| complex(kind=sp), | intent(in) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=sp), | intent(in) | :: | af(ldaf,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldaf | |||
| complex(kind=sp), | intent(in) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| complex(kind=sp), | intent(inout) | :: | x(ldx,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldx | |||
| real(kind=sp), | intent(out) | :: | ferr(*) | |||
| real(kind=sp), | intent(out) | :: | berr(*) | |||
| complex(kind=sp), | intent(out) | :: | work(*) | |||
| real(kind=sp), | intent(out) | :: | rwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
DPORFS improves the computed solution to a system of linear equations when the coefficient matrix is symmetric positive definite, and provides error bounds and backward error estimates for the solution.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| real(kind=dp), | intent(in) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=dp), | intent(in) | :: | af(ldaf,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldaf | |||
| real(kind=dp), | intent(in) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| real(kind=dp), | intent(inout) | :: | x(ldx,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldx | |||
| real(kind=dp), | intent(out) | :: | ferr(*) | |||
| real(kind=dp), | intent(out) | :: | berr(*) | |||
| real(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | iwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
SPORFS improves the computed solution to a system of linear equations when the coefficient matrix is symmetric positive definite, and provides error bounds and backward error estimates for the solution.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| real(kind=sp), | intent(in) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=sp), | intent(in) | :: | af(ldaf,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldaf | |||
| real(kind=sp), | intent(in) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| real(kind=sp), | intent(inout) | :: | x(ldx,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldx | |||
| real(kind=sp), | intent(out) | :: | ferr(*) | |||
| real(kind=sp), | intent(out) | :: | berr(*) | |||
| real(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | iwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
ZPORFS improves the computed solution to a system of linear equations when the coefficient matrix is Hermitian positive definite, and provides error bounds and backward error estimates for the solution.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| complex(kind=dp), | intent(in) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=dp), | intent(in) | :: | af(ldaf,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldaf | |||
| complex(kind=dp), | intent(in) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| complex(kind=dp), | intent(inout) | :: | x(ldx,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldx | |||
| real(kind=dp), | intent(out) | :: | ferr(*) | |||
| real(kind=dp), | intent(out) | :: | berr(*) | |||
| complex(kind=dp), | intent(out) | :: | work(*) | |||
| real(kind=dp), | intent(out) | :: | rwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
POSV computes the solution to a complex system of linear equations A * X = B, where A is an N-by-N Hermitian positive definite matrix and X and B are N-by-NRHS matrices. The Cholesky decomposition is used to factor A as A = UH* U, if UPLO = 'U', or A = L * LH, if UPLO = 'L', where U is an upper triangular matrix and L is a lower triangular matrix. The factored form of A is then used to solve the system of equations A * X = B.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| complex(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=sp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| real(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=dp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| real(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=sp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| complex(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=dp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| integer(kind=ilp), | intent(out) | :: | info |
CPOSV computes the solution to a complex system of linear equations A * X = B, where A is an N-by-N Hermitian positive definite matrix and X and B are N-by-NRHS matrices. The Cholesky decomposition is used to factor A as A = UH* U, if UPLO = 'U', or A = L * LH, if UPLO = 'L', where U is an upper triangular matrix and L is a lower triangular matrix. The factored form of A is then used to solve the system of equations A * X = B.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| complex(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=sp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| integer(kind=ilp), | intent(out) | :: | info |
DPOSV computes the solution to a real system of linear equations A * X = B, where A is an N-by-N symmetric positive definite matrix and X and B are N-by-NRHS matrices. The Cholesky decomposition is used to factor A as A = UT* U, if UPLO = 'U', or A = L * LT, if UPLO = 'L', where U is an upper triangular matrix and L is a lower triangular matrix. The factored form of A is then used to solve the system of equations A * X = B.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| real(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=dp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| integer(kind=ilp), | intent(out) | :: | info |
SPOSV computes the solution to a real system of linear equations A * X = B, where A is an N-by-N symmetric positive definite matrix and X and B are N-by-NRHS matrices. The Cholesky decomposition is used to factor A as A = UT* U, if UPLO = 'U', or A = L * LT, if UPLO = 'L', where U is an upper triangular matrix and L is a lower triangular matrix. The factored form of A is then used to solve the system of equations A * X = B.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| real(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=sp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| integer(kind=ilp), | intent(out) | :: | info |
ZPOSV computes the solution to a complex system of linear equations A * X = B, where A is an N-by-N Hermitian positive definite matrix and X and B are N-by-NRHS matrices. The Cholesky decomposition is used to factor A as A = UH* U, if UPLO = 'U', or A = L * LH, if UPLO = 'L', where U is an upper triangular matrix and L is a lower triangular matrix. The factored form of A is then used to solve the system of equations A * X = B.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| complex(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=dp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| integer(kind=ilp), | intent(out) | :: | info |
POTRF computes the Cholesky factorization of a complex Hermitian positive definite matrix A. The factorization has the form A = UH * U, if UPLO = 'U', or A = L * LH, if UPLO = 'L', where U is an upper triangular matrix and L is lower triangular. This is the block version of the algorithm, calling Level 3 BLAS.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| integer(kind=ilp), | intent(out) | :: | info |
CPOTRF computes the Cholesky factorization of a complex Hermitian positive definite matrix A. The factorization has the form A = UH * U, if UPLO = 'U', or A = L * LH, if UPLO = 'L', where U is an upper triangular matrix and L is lower triangular. This is the block version of the algorithm, calling Level 3 BLAS.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| integer(kind=ilp), | intent(out) | :: | info |
DPOTRF computes the Cholesky factorization of a real symmetric positive definite matrix A. The factorization has the form A = UT * U, if UPLO = 'U', or A = L * LT, if UPLO = 'L', where U is an upper triangular matrix and L is lower triangular. This is the block version of the algorithm, calling Level 3 BLAS.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| integer(kind=ilp), | intent(out) | :: | info |
SPOTRF computes the Cholesky factorization of a real symmetric positive definite matrix A. The factorization has the form A = UT * U, if UPLO = 'U', or A = L * LT, if UPLO = 'L', where U is an upper triangular matrix and L is lower triangular. This is the block version of the algorithm, calling Level 3 BLAS.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| integer(kind=ilp), | intent(out) | :: | info |
ZPOTRF computes the Cholesky factorization of a complex Hermitian positive definite matrix A. The factorization has the form A = UH * U, if UPLO = 'U', or A = L * LH, if UPLO = 'L', where U is an upper triangular matrix and L is lower triangular. This is the block version of the algorithm, calling Level 3 BLAS.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| integer(kind=ilp), | intent(out) | :: | info |
POTRF2 computes the Cholesky factorization of a Hermitian positive definite matrix A using the recursive algorithm. The factorization has the form A = UH * U, if UPLO = 'U', or A = L * LH, if UPLO = 'L', where U is an upper triangular matrix and L is lower triangular. This is the recursive version of the algorithm. It divides the matrix into four submatrices: [ A11 | A12 ] where A11 is n1 by n1 and A22 is n2 by n2 A = [ -----|----- ] with n1 = n/2 [ A21 | A22 ] n2 = n-n1 The subroutine calls itself to factor A11. Update and scale A21 or A12, update A22 then calls itself to factor A22.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| integer(kind=ilp), | intent(out) | :: | info |
CPOTRF2 computes the Cholesky factorization of a Hermitian positive definite matrix A using the recursive algorithm. The factorization has the form A = UH * U, if UPLO = 'U', or A = L * LH, if UPLO = 'L', where U is an upper triangular matrix and L is lower triangular. This is the recursive version of the algorithm. It divides the matrix into four submatrices: [ A11 | A12 ] where A11 is n1 by n1 and A22 is n2 by n2 A = [ -----|----- ] with n1 = n/2 [ A21 | A22 ] n2 = n-n1 The subroutine calls itself to factor A11. Update and scale A21 or A12, update A22 then calls itself to factor A22.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| integer(kind=ilp), | intent(out) | :: | info |
DPOTRF2 computes the Cholesky factorization of a real symmetric positive definite matrix A using the recursive algorithm. The factorization has the form A = UT * U, if UPLO = 'U', or A = L * LT, if UPLO = 'L', where U is an upper triangular matrix and L is lower triangular. This is the recursive version of the algorithm. It divides the matrix into four submatrices: [ A11 | A12 ] where A11 is n1 by n1 and A22 is n2 by n2 A = [ -----|----- ] with n1 = n/2 [ A21 | A22 ] n2 = n-n1 The subroutine calls itself to factor A11. Update and scale A21 or A12, update A22 then calls itself to factor A22.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| integer(kind=ilp), | intent(out) | :: | info |
SPOTRF2 computes the Cholesky factorization of a real symmetric positive definite matrix A using the recursive algorithm. The factorization has the form A = UT * U, if UPLO = 'U', or A = L * LT, if UPLO = 'L', where U is an upper triangular matrix and L is lower triangular. This is the recursive version of the algorithm. It divides the matrix into four submatrices: [ A11 | A12 ] where A11 is n1 by n1 and A22 is n2 by n2 A = [ -----|----- ] with n1 = n/2 [ A21 | A22 ] n2 = n-n1 The subroutine calls itself to factor A11. Update and scale A21 or A12, update A22 then call itself to factor A22.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| integer(kind=ilp), | intent(out) | :: | info |
ZPOTRF2 computes the Cholesky factorization of a Hermitian positive definite matrix A using the recursive algorithm. The factorization has the form A = UH * U, if UPLO = 'U', or A = L * LH, if UPLO = 'L', where U is an upper triangular matrix and L is lower triangular. This is the recursive version of the algorithm. It divides the matrix into four submatrices: [ A11 | A12 ] where A11 is n1 by n1 and A22 is n2 by n2 A = [ -----|----- ] with n1 = n/2 [ A21 | A22 ] n2 = n-n1 The subroutine calls itself to factor A11. Update and scale A21 or A12, update A22 then call itself to factor A22.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| integer(kind=ilp), | intent(out) | :: | info |
POTRI computes the inverse of a complex Hermitian positive definite matrix A using the Cholesky factorization A = UHU or A = LLH computed by CPOTRF.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| integer(kind=ilp), | intent(out) | :: | info |
CPOTRI computes the inverse of a complex Hermitian positive definite matrix A using the Cholesky factorization A = UHU or A = LLH computed by CPOTRF.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| integer(kind=ilp), | intent(out) | :: | info |
DPOTRI computes the inverse of a real symmetric positive definite matrix A using the Cholesky factorization A = UTU or A = LLT computed by DPOTRF.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| integer(kind=ilp), | intent(out) | :: | info |
SPOTRI computes the inverse of a real symmetric positive definite matrix A using the Cholesky factorization A = UTU or A = LLT computed by SPOTRF.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| integer(kind=ilp), | intent(out) | :: | info |
ZPOTRI computes the inverse of a complex Hermitian positive definite matrix A using the Cholesky factorization A = UHU or A = LLH computed by ZPOTRF.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| integer(kind=ilp), | intent(out) | :: | info |
POTRS solves a system of linear equations AX = B with a Hermitian positive definite matrix A using the Cholesky factorization A = UHU or A = LL*H computed by CPOTRF.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| complex(kind=sp), | intent(in) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=sp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| real(kind=dp), | intent(in) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=dp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| real(kind=sp), | intent(in) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=sp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| complex(kind=dp), | intent(in) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=dp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| integer(kind=ilp), | intent(out) | :: | info |
CPOTRS solves a system of linear equations AX = B with a Hermitian positive definite matrix A using the Cholesky factorization A = UHU or A = LL*H computed by CPOTRF.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| complex(kind=sp), | intent(in) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=sp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| integer(kind=ilp), | intent(out) | :: | info |
DPOTRS solves a system of linear equations AX = B with a symmetric positive definite matrix A using the Cholesky factorization A = UTU or A = LL*T computed by DPOTRF.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| real(kind=dp), | intent(in) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=dp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| integer(kind=ilp), | intent(out) | :: | info |
SPOTRS solves a system of linear equations AX = B with a symmetric positive definite matrix A using the Cholesky factorization A = UTU or A = LL*T computed by SPOTRF.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| real(kind=sp), | intent(in) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=sp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| integer(kind=ilp), | intent(out) | :: | info |
ZPOTRS solves a system of linear equations AX = B with a Hermitian positive definite matrix A using the Cholesky factorization A = UH * U or A = L * L*H computed by ZPOTRF.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| complex(kind=dp), | intent(in) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=dp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| integer(kind=ilp), | intent(out) | :: | info |
PPCON estimates the reciprocal of the condition number (in the 1-norm) of a complex Hermitian positive definite packed matrix using the Cholesky factorization A = UHU or A = LLH computed by CPPTRF. An estimate is obtained for norm(inv(A)), and the reciprocal of the condition number is computed as RCOND = 1 / (ANORM * norm(inv(A))).
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=sp), | intent(in) | :: | ap(*) | |||
| real(kind=sp), | intent(in) | :: | anorm | |||
| real(kind=sp), | intent(out) | :: | rcond | |||
| complex(kind=sp), | intent(out) | :: | work(*) | |||
| real(kind=sp), | intent(out) | :: | rwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=dp), | intent(in) | :: | ap(*) | |||
| real(kind=dp), | intent(in) | :: | anorm | |||
| real(kind=dp), | intent(out) | :: | rcond | |||
| real(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | iwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=sp), | intent(in) | :: | ap(*) | |||
| real(kind=sp), | intent(in) | :: | anorm | |||
| real(kind=sp), | intent(out) | :: | rcond | |||
| real(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | iwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=dp), | intent(in) | :: | ap(*) | |||
| real(kind=dp), | intent(in) | :: | anorm | |||
| real(kind=dp), | intent(out) | :: | rcond | |||
| complex(kind=dp), | intent(out) | :: | work(*) | |||
| real(kind=dp), | intent(out) | :: | rwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
CPPCON estimates the reciprocal of the condition number (in the 1-norm) of a complex Hermitian positive definite packed matrix using the Cholesky factorization A = UHU or A = LLH computed by CPPTRF. An estimate is obtained for norm(inv(A)), and the reciprocal of the condition number is computed as RCOND = 1 / (ANORM * norm(inv(A))).
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=sp), | intent(in) | :: | ap(*) | |||
| real(kind=sp), | intent(in) | :: | anorm | |||
| real(kind=sp), | intent(out) | :: | rcond | |||
| complex(kind=sp), | intent(out) | :: | work(*) | |||
| real(kind=sp), | intent(out) | :: | rwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
DPPCON estimates the reciprocal of the condition number (in the 1-norm) of a real symmetric positive definite packed matrix using the Cholesky factorization A = UTU or A = LLT computed by DPPTRF. An estimate is obtained for norm(inv(A)), and the reciprocal of the condition number is computed as RCOND = 1 / (ANORM * norm(inv(A))).
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=dp), | intent(in) | :: | ap(*) | |||
| real(kind=dp), | intent(in) | :: | anorm | |||
| real(kind=dp), | intent(out) | :: | rcond | |||
| real(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | iwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
SPPCON estimates the reciprocal of the condition number (in the 1-norm) of a real symmetric positive definite packed matrix using the Cholesky factorization A = UTU or A = LLT computed by SPPTRF. An estimate is obtained for norm(inv(A)), and the reciprocal of the condition number is computed as RCOND = 1 / (ANORM * norm(inv(A))).
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=sp), | intent(in) | :: | ap(*) | |||
| real(kind=sp), | intent(in) | :: | anorm | |||
| real(kind=sp), | intent(out) | :: | rcond | |||
| real(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | iwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
ZPPCON estimates the reciprocal of the condition number (in the 1-norm) of a complex Hermitian positive definite packed matrix using the Cholesky factorization A = UHU or A = LLH computed by ZPPTRF. An estimate is obtained for norm(inv(A)), and the reciprocal of the condition number is computed as RCOND = 1 / (ANORM * norm(inv(A))).
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=dp), | intent(in) | :: | ap(*) | |||
| real(kind=dp), | intent(in) | :: | anorm | |||
| real(kind=dp), | intent(out) | :: | rcond | |||
| complex(kind=dp), | intent(out) | :: | work(*) | |||
| real(kind=dp), | intent(out) | :: | rwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
PPEQU computes row and column scalings intended to equilibrate a Hermitian positive definite matrix A in packed storage and reduce its condition number (with respect to the two-norm). S contains the scale factors, S(i)=1/sqrt(A(i,i)), chosen so that the scaled matrix B with elements B(i,j)=S(i)A(i,j)S(j) has ones on the diagonal. This choice of S puts the condition number of B within a factor N of the smallest possible condition number over all possible diagonal scalings.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=sp), | intent(in) | :: | ap(*) | |||
| real(kind=sp), | intent(out) | :: | s(*) | |||
| real(kind=sp), | intent(out) | :: | scond | |||
| real(kind=sp), | intent(out) | :: | amax | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=dp), | intent(in) | :: | ap(*) | |||
| real(kind=dp), | intent(out) | :: | s(*) | |||
| real(kind=dp), | intent(out) | :: | scond | |||
| real(kind=dp), | intent(out) | :: | amax | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=sp), | intent(in) | :: | ap(*) | |||
| real(kind=sp), | intent(out) | :: | s(*) | |||
| real(kind=sp), | intent(out) | :: | scond | |||
| real(kind=sp), | intent(out) | :: | amax | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=dp), | intent(in) | :: | ap(*) | |||
| real(kind=dp), | intent(out) | :: | s(*) | |||
| real(kind=dp), | intent(out) | :: | scond | |||
| real(kind=dp), | intent(out) | :: | amax | |||
| integer(kind=ilp), | intent(out) | :: | info |
CPPEQU computes row and column scalings intended to equilibrate a Hermitian positive definite matrix A in packed storage and reduce its condition number (with respect to the two-norm). S contains the scale factors, S(i)=1/sqrt(A(i,i)), chosen so that the scaled matrix B with elements B(i,j)=S(i)A(i,j)S(j) has ones on the diagonal. This choice of S puts the condition number of B within a factor N of the smallest possible condition number over all possible diagonal scalings.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=sp), | intent(in) | :: | ap(*) | |||
| real(kind=sp), | intent(out) | :: | s(*) | |||
| real(kind=sp), | intent(out) | :: | scond | |||
| real(kind=sp), | intent(out) | :: | amax | |||
| integer(kind=ilp), | intent(out) | :: | info |
DPPEQU computes row and column scalings intended to equilibrate a symmetric positive definite matrix A in packed storage and reduce its condition number (with respect to the two-norm). S contains the scale factors, S(i)=1/sqrt(A(i,i)), chosen so that the scaled matrix B with elements B(i,j)=S(i)A(i,j)S(j) has ones on the diagonal. This choice of S puts the condition number of B within a factor N of the smallest possible condition number over all possible diagonal scalings.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=dp), | intent(in) | :: | ap(*) | |||
| real(kind=dp), | intent(out) | :: | s(*) | |||
| real(kind=dp), | intent(out) | :: | scond | |||
| real(kind=dp), | intent(out) | :: | amax | |||
| integer(kind=ilp), | intent(out) | :: | info |
SPPEQU computes row and column scalings intended to equilibrate a symmetric positive definite matrix A in packed storage and reduce its condition number (with respect to the two-norm). S contains the scale factors, S(i)=1/sqrt(A(i,i)), chosen so that the scaled matrix B with elements B(i,j)=S(i)A(i,j)S(j) has ones on the diagonal. This choice of S puts the condition number of B within a factor N of the smallest possible condition number over all possible diagonal scalings.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=sp), | intent(in) | :: | ap(*) | |||
| real(kind=sp), | intent(out) | :: | s(*) | |||
| real(kind=sp), | intent(out) | :: | scond | |||
| real(kind=sp), | intent(out) | :: | amax | |||
| integer(kind=ilp), | intent(out) | :: | info |
ZPPEQU computes row and column scalings intended to equilibrate a Hermitian positive definite matrix A in packed storage and reduce its condition number (with respect to the two-norm). S contains the scale factors, S(i)=1/sqrt(A(i,i)), chosen so that the scaled matrix B with elements B(i,j)=S(i)A(i,j)S(j) has ones on the diagonal. This choice of S puts the condition number of B within a factor N of the smallest possible condition number over all possible diagonal scalings.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=dp), | intent(in) | :: | ap(*) | |||
| real(kind=dp), | intent(out) | :: | s(*) | |||
| real(kind=dp), | intent(out) | :: | scond | |||
| real(kind=dp), | intent(out) | :: | amax | |||
| integer(kind=ilp), | intent(out) | :: | info |
PPRFS improves the computed solution to a system of linear equations when the coefficient matrix is Hermitian positive definite and packed, and provides error bounds and backward error estimates for the solution.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| complex(kind=sp), | intent(in) | :: | ap(*) | |||
| complex(kind=sp), | intent(in) | :: | afp(*) | |||
| complex(kind=sp), | intent(in) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| complex(kind=sp), | intent(inout) | :: | x(ldx,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldx | |||
| real(kind=sp), | intent(out) | :: | ferr(*) | |||
| real(kind=sp), | intent(out) | :: | berr(*) | |||
| complex(kind=sp), | intent(out) | :: | work(*) | |||
| real(kind=sp), | intent(out) | :: | rwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| real(kind=dp), | intent(in) | :: | ap(*) | |||
| real(kind=dp), | intent(in) | :: | afp(*) | |||
| real(kind=dp), | intent(in) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| real(kind=dp), | intent(inout) | :: | x(ldx,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldx | |||
| real(kind=dp), | intent(out) | :: | ferr(*) | |||
| real(kind=dp), | intent(out) | :: | berr(*) | |||
| real(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | iwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| real(kind=sp), | intent(in) | :: | ap(*) | |||
| real(kind=sp), | intent(in) | :: | afp(*) | |||
| real(kind=sp), | intent(in) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| real(kind=sp), | intent(inout) | :: | x(ldx,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldx | |||
| real(kind=sp), | intent(out) | :: | ferr(*) | |||
| real(kind=sp), | intent(out) | :: | berr(*) | |||
| real(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | iwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| complex(kind=dp), | intent(in) | :: | ap(*) | |||
| complex(kind=dp), | intent(in) | :: | afp(*) | |||
| complex(kind=dp), | intent(in) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| complex(kind=dp), | intent(inout) | :: | x(ldx,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldx | |||
| real(kind=dp), | intent(out) | :: | ferr(*) | |||
| real(kind=dp), | intent(out) | :: | berr(*) | |||
| complex(kind=dp), | intent(out) | :: | work(*) | |||
| real(kind=dp), | intent(out) | :: | rwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
CPPRFS improves the computed solution to a system of linear equations when the coefficient matrix is Hermitian positive definite and packed, and provides error bounds and backward error estimates for the solution.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| complex(kind=sp), | intent(in) | :: | ap(*) | |||
| complex(kind=sp), | intent(in) | :: | afp(*) | |||
| complex(kind=sp), | intent(in) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| complex(kind=sp), | intent(inout) | :: | x(ldx,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldx | |||
| real(kind=sp), | intent(out) | :: | ferr(*) | |||
| real(kind=sp), | intent(out) | :: | berr(*) | |||
| complex(kind=sp), | intent(out) | :: | work(*) | |||
| real(kind=sp), | intent(out) | :: | rwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
DPPRFS improves the computed solution to a system of linear equations when the coefficient matrix is symmetric positive definite and packed, and provides error bounds and backward error estimates for the solution.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| real(kind=dp), | intent(in) | :: | ap(*) | |||
| real(kind=dp), | intent(in) | :: | afp(*) | |||
| real(kind=dp), | intent(in) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| real(kind=dp), | intent(inout) | :: | x(ldx,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldx | |||
| real(kind=dp), | intent(out) | :: | ferr(*) | |||
| real(kind=dp), | intent(out) | :: | berr(*) | |||
| real(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | iwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
SPPRFS improves the computed solution to a system of linear equations when the coefficient matrix is symmetric positive definite and packed, and provides error bounds and backward error estimates for the solution.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| real(kind=sp), | intent(in) | :: | ap(*) | |||
| real(kind=sp), | intent(in) | :: | afp(*) | |||
| real(kind=sp), | intent(in) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| real(kind=sp), | intent(inout) | :: | x(ldx,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldx | |||
| real(kind=sp), | intent(out) | :: | ferr(*) | |||
| real(kind=sp), | intent(out) | :: | berr(*) | |||
| real(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | iwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
ZPPRFS improves the computed solution to a system of linear equations when the coefficient matrix is Hermitian positive definite and packed, and provides error bounds and backward error estimates for the solution.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| complex(kind=dp), | intent(in) | :: | ap(*) | |||
| complex(kind=dp), | intent(in) | :: | afp(*) | |||
| complex(kind=dp), | intent(in) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| complex(kind=dp), | intent(inout) | :: | x(ldx,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldx | |||
| real(kind=dp), | intent(out) | :: | ferr(*) | |||
| real(kind=dp), | intent(out) | :: | berr(*) | |||
| complex(kind=dp), | intent(out) | :: | work(*) | |||
| real(kind=dp), | intent(out) | :: | rwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
PPSV computes the solution to a complex system of linear equations A * X = B, where A is an N-by-N Hermitian positive definite matrix stored in packed format and X and B are N-by-NRHS matrices. The Cholesky decomposition is used to factor A as A = UH * U, if UPLO = 'U', or A = L * LH, if UPLO = 'L', where U is an upper triangular matrix and L is a lower triangular matrix. The factored form of A is then used to solve the system of equations A * X = B.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| complex(kind=sp), | intent(inout) | :: | ap(*) | |||
| complex(kind=sp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| real(kind=dp), | intent(inout) | :: | ap(*) | |||
| real(kind=dp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| real(kind=sp), | intent(inout) | :: | ap(*) | |||
| real(kind=sp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| complex(kind=dp), | intent(inout) | :: | ap(*) | |||
| complex(kind=dp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| integer(kind=ilp), | intent(out) | :: | info |
CPPSV computes the solution to a complex system of linear equations A * X = B, where A is an N-by-N Hermitian positive definite matrix stored in packed format and X and B are N-by-NRHS matrices. The Cholesky decomposition is used to factor A as A = UH * U, if UPLO = 'U', or A = L * LH, if UPLO = 'L', where U is an upper triangular matrix and L is a lower triangular matrix. The factored form of A is then used to solve the system of equations A * X = B.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| complex(kind=sp), | intent(inout) | :: | ap(*) | |||
| complex(kind=sp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| integer(kind=ilp), | intent(out) | :: | info |
DPPSV computes the solution to a real system of linear equations A * X = B, where A is an N-by-N symmetric positive definite matrix stored in packed format and X and B are N-by-NRHS matrices. The Cholesky decomposition is used to factor A as A = UT* U, if UPLO = 'U', or A = L * LT, if UPLO = 'L', where U is an upper triangular matrix and L is a lower triangular matrix. The factored form of A is then used to solve the system of equations A * X = B.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| real(kind=dp), | intent(inout) | :: | ap(*) | |||
| real(kind=dp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| integer(kind=ilp), | intent(out) | :: | info |
SPPSV computes the solution to a real system of linear equations A * X = B, where A is an N-by-N symmetric positive definite matrix stored in packed format and X and B are N-by-NRHS matrices. The Cholesky decomposition is used to factor A as A = UT* U, if UPLO = 'U', or A = L * LT, if UPLO = 'L', where U is an upper triangular matrix and L is a lower triangular matrix. The factored form of A is then used to solve the system of equations A * X = B.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| real(kind=sp), | intent(inout) | :: | ap(*) | |||
| real(kind=sp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| integer(kind=ilp), | intent(out) | :: | info |
ZPPSV computes the solution to a complex system of linear equations A * X = B, where A is an N-by-N Hermitian positive definite matrix stored in packed format and X and B are N-by-NRHS matrices. The Cholesky decomposition is used to factor A as A = UH * U, if UPLO = 'U', or A = L * LH, if UPLO = 'L', where U is an upper triangular matrix and L is a lower triangular matrix. The factored form of A is then used to solve the system of equations A * X = B.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| complex(kind=dp), | intent(inout) | :: | ap(*) | |||
| complex(kind=dp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| integer(kind=ilp), | intent(out) | :: | info |
PPTRF computes the Cholesky factorization of a complex Hermitian positive definite matrix A stored in packed format. The factorization has the form A = UH * U, if UPLO = 'U', or A = L * LH, if UPLO = 'L', where U is an upper triangular matrix and L is lower triangular.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=sp), | intent(inout) | :: | ap(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=dp), | intent(inout) | :: | ap(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=sp), | intent(inout) | :: | ap(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=dp), | intent(inout) | :: | ap(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
CPPTRF computes the Cholesky factorization of a complex Hermitian positive definite matrix A stored in packed format. The factorization has the form A = UH * U, if UPLO = 'U', or A = L * LH, if UPLO = 'L', where U is an upper triangular matrix and L is lower triangular.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=sp), | intent(inout) | :: | ap(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
DPPTRF computes the Cholesky factorization of a real symmetric positive definite matrix A stored in packed format. The factorization has the form A = UT * U, if UPLO = 'U', or A = L * LT, if UPLO = 'L', where U is an upper triangular matrix and L is lower triangular.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=dp), | intent(inout) | :: | ap(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
SPPTRF computes the Cholesky factorization of a real symmetric positive definite matrix A stored in packed format. The factorization has the form A = UT * U, if UPLO = 'U', or A = L * LT, if UPLO = 'L', where U is an upper triangular matrix and L is lower triangular.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=sp), | intent(inout) | :: | ap(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
ZPPTRF computes the Cholesky factorization of a complex Hermitian positive definite matrix A stored in packed format. The factorization has the form A = UH * U, if UPLO = 'U', or A = L * LH, if UPLO = 'L', where U is an upper triangular matrix and L is lower triangular.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=dp), | intent(inout) | :: | ap(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
PPTRI computes the inverse of a complex Hermitian positive definite matrix A using the Cholesky factorization A = UHU or A = LLH computed by CPPTRF.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=sp), | intent(inout) | :: | ap(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=dp), | intent(inout) | :: | ap(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=sp), | intent(inout) | :: | ap(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=dp), | intent(inout) | :: | ap(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
CPPTRI computes the inverse of a complex Hermitian positive definite matrix A using the Cholesky factorization A = UHU or A = LLH computed by CPPTRF.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=sp), | intent(inout) | :: | ap(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
DPPTRI computes the inverse of a real symmetric positive definite matrix A using the Cholesky factorization A = UTU or A = LLT computed by DPPTRF.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=dp), | intent(inout) | :: | ap(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
SPPTRI computes the inverse of a real symmetric positive definite matrix A using the Cholesky factorization A = UTU or A = LLT computed by SPPTRF.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=sp), | intent(inout) | :: | ap(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
ZPPTRI computes the inverse of a complex Hermitian positive definite matrix A using the Cholesky factorization A = UHU or A = LLH computed by ZPPTRF.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=dp), | intent(inout) | :: | ap(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
PPTRS solves a system of linear equations AX = B with a Hermitian positive definite matrix A in packed storage using the Cholesky factorization A = UHU or A = LL*H computed by CPPTRF.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| complex(kind=sp), | intent(in) | :: | ap(*) | |||
| complex(kind=sp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| real(kind=dp), | intent(in) | :: | ap(*) | |||
| real(kind=dp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| real(kind=sp), | intent(in) | :: | ap(*) | |||
| real(kind=sp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| complex(kind=dp), | intent(in) | :: | ap(*) | |||
| complex(kind=dp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| integer(kind=ilp), | intent(out) | :: | info |
CPPTRS solves a system of linear equations AX = B with a Hermitian positive definite matrix A in packed storage using the Cholesky factorization A = UHU or A = LL*H computed by CPPTRF.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| complex(kind=sp), | intent(in) | :: | ap(*) | |||
| complex(kind=sp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| integer(kind=ilp), | intent(out) | :: | info |
DPPTRS solves a system of linear equations AX = B with a symmetric positive definite matrix A in packed storage using the Cholesky factorization A = UTU or A = LL*T computed by DPPTRF.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| real(kind=dp), | intent(in) | :: | ap(*) | |||
| real(kind=dp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| integer(kind=ilp), | intent(out) | :: | info |
SPPTRS solves a system of linear equations AX = B with a symmetric positive definite matrix A in packed storage using the Cholesky factorization A = UTU or A = LL*T computed by SPPTRF.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| real(kind=sp), | intent(in) | :: | ap(*) | |||
| real(kind=sp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| integer(kind=ilp), | intent(out) | :: | info |
ZPPTRS solves a system of linear equations AX = B with a Hermitian positive definite matrix A in packed storage using the Cholesky factorization A = UH * U or A = L * L*H computed by ZPPTRF.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| complex(kind=dp), | intent(in) | :: | ap(*) | |||
| complex(kind=dp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| integer(kind=ilp), | intent(out) | :: | info |
PSTRF computes the Cholesky factorization with complete pivoting of a complex Hermitian positive semidefinite matrix A. The factorization has the form PT * A * P = UH * U , if UPLO = 'U', PT * A * P = L * LH, if UPLO = 'L', where U is an upper triangular matrix and L is lower triangular, and P is stored as vector PIV. This algorithm does not attempt to check that A is positive semidefinite. This version of the algorithm calls level 3 BLAS.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| integer(kind=ilp), | intent(out) | :: | piv(n) | |||
| integer(kind=ilp), | intent(out) | :: | rank | |||
| real(kind=sp), | intent(in) | :: | tol | |||
| real(kind=sp), | intent(out) | :: | work(2*n) | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| integer(kind=ilp), | intent(out) | :: | piv(n) | |||
| integer(kind=ilp), | intent(out) | :: | rank | |||
| real(kind=dp), | intent(in) | :: | tol | |||
| real(kind=dp), | intent(out) | :: | work(2*n) | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| integer(kind=ilp), | intent(out) | :: | piv(n) | |||
| integer(kind=ilp), | intent(out) | :: | rank | |||
| real(kind=sp), | intent(in) | :: | tol | |||
| real(kind=sp), | intent(out) | :: | work(2*n) | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| integer(kind=ilp), | intent(out) | :: | piv(n) | |||
| integer(kind=ilp), | intent(out) | :: | rank | |||
| real(kind=dp), | intent(in) | :: | tol | |||
| real(kind=dp), | intent(out) | :: | work(2*n) | |||
| integer(kind=ilp), | intent(out) | :: | info |
CPSTRF computes the Cholesky factorization with complete pivoting of a complex Hermitian positive semidefinite matrix A. The factorization has the form PT * A * P = UH * U , if UPLO = 'U', PT * A * P = L * LH, if UPLO = 'L', where U is an upper triangular matrix and L is lower triangular, and P is stored as vector PIV. This algorithm does not attempt to check that A is positive semidefinite. This version of the algorithm calls level 3 BLAS.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| integer(kind=ilp), | intent(out) | :: | piv(n) | |||
| integer(kind=ilp), | intent(out) | :: | rank | |||
| real(kind=sp), | intent(in) | :: | tol | |||
| real(kind=sp), | intent(out) | :: | work(2*n) | |||
| integer(kind=ilp), | intent(out) | :: | info |
DPSTRF computes the Cholesky factorization with complete pivoting of a real symmetric positive semidefinite matrix A. The factorization has the form PT * A * P = UT * U , if UPLO = 'U', PT * A * P = L * LT, if UPLO = 'L', where U is an upper triangular matrix and L is lower triangular, and P is stored as vector PIV. This algorithm does not attempt to check that A is positive semidefinite. This version of the algorithm calls level 3 BLAS.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| integer(kind=ilp), | intent(out) | :: | piv(n) | |||
| integer(kind=ilp), | intent(out) | :: | rank | |||
| real(kind=dp), | intent(in) | :: | tol | |||
| real(kind=dp), | intent(out) | :: | work(2*n) | |||
| integer(kind=ilp), | intent(out) | :: | info |
SPSTRF computes the Cholesky factorization with complete pivoting of a real symmetric positive semidefinite matrix A. The factorization has the form PT * A * P = UT * U , if UPLO = 'U', PT * A * P = L * LT, if UPLO = 'L', where U is an upper triangular matrix and L is lower triangular, and P is stored as vector PIV. This algorithm does not attempt to check that A is positive semidefinite. This version of the algorithm calls level 3 BLAS.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| integer(kind=ilp), | intent(out) | :: | piv(n) | |||
| integer(kind=ilp), | intent(out) | :: | rank | |||
| real(kind=sp), | intent(in) | :: | tol | |||
| real(kind=sp), | intent(out) | :: | work(2*n) | |||
| integer(kind=ilp), | intent(out) | :: | info |
ZPSTRF computes the Cholesky factorization with complete pivoting of a complex Hermitian positive semidefinite matrix A. The factorization has the form PT * A * P = UH * U , if UPLO = 'U', PT * A * P = L * LH, if UPLO = 'L', where U is an upper triangular matrix and L is lower triangular, and P is stored as vector PIV. This algorithm does not attempt to check that A is positive semidefinite. This version of the algorithm calls level 3 BLAS.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| integer(kind=ilp), | intent(out) | :: | piv(n) | |||
| integer(kind=ilp), | intent(out) | :: | rank | |||
| real(kind=dp), | intent(in) | :: | tol | |||
| real(kind=dp), | intent(out) | :: | work(2*n) | |||
| integer(kind=ilp), | intent(out) | :: | info |
PTCON computes the reciprocal of the condition number (in the 1-norm) of a complex Hermitian positive definite tridiagonal matrix using the factorization A = LDLH or A = UHDU computed by CPTTRF. Norm(inv(A)) is computed by a direct method, and the reciprocal of the condition number is computed as RCOND = 1 / (ANORM * norm(inv(A))).
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=sp), | intent(in) | :: | d(*) | |||
| complex(kind=sp), | intent(in) | :: | e(*) | |||
| real(kind=sp), | intent(in) | :: | anorm | |||
| real(kind=sp), | intent(out) | :: | rcond | |||
| real(kind=sp), | intent(out) | :: | rwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=dp), | intent(in) | :: | d(*) | |||
| real(kind=dp), | intent(in) | :: | e(*) | |||
| real(kind=dp), | intent(in) | :: | anorm | |||
| real(kind=dp), | intent(out) | :: | rcond | |||
| real(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=sp), | intent(in) | :: | d(*) | |||
| real(kind=sp), | intent(in) | :: | e(*) | |||
| real(kind=sp), | intent(in) | :: | anorm | |||
| real(kind=sp), | intent(out) | :: | rcond | |||
| real(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=dp), | intent(in) | :: | d(*) | |||
| complex(kind=dp), | intent(in) | :: | e(*) | |||
| real(kind=dp), | intent(in) | :: | anorm | |||
| real(kind=dp), | intent(out) | :: | rcond | |||
| real(kind=dp), | intent(out) | :: | rwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
CPTCON computes the reciprocal of the condition number (in the 1-norm) of a complex Hermitian positive definite tridiagonal matrix using the factorization A = LDLH or A = UHDU computed by CPTTRF. Norm(inv(A)) is computed by a direct method, and the reciprocal of the condition number is computed as RCOND = 1 / (ANORM * norm(inv(A))).
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=sp), | intent(in) | :: | d(*) | |||
| complex(kind=sp), | intent(in) | :: | e(*) | |||
| real(kind=sp), | intent(in) | :: | anorm | |||
| real(kind=sp), | intent(out) | :: | rcond | |||
| real(kind=sp), | intent(out) | :: | rwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
DPTCON computes the reciprocal of the condition number (in the 1-norm) of a real symmetric positive definite tridiagonal matrix using the factorization A = LDLT or A = UTDU computed by DPTTRF. Norm(inv(A)) is computed by a direct method, and the reciprocal of the condition number is computed as RCOND = 1 / (ANORM * norm(inv(A))).
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=dp), | intent(in) | :: | d(*) | |||
| real(kind=dp), | intent(in) | :: | e(*) | |||
| real(kind=dp), | intent(in) | :: | anorm | |||
| real(kind=dp), | intent(out) | :: | rcond | |||
| real(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
SPTCON computes the reciprocal of the condition number (in the 1-norm) of a real symmetric positive definite tridiagonal matrix using the factorization A = LDLT or A = UTDU computed by SPTTRF. Norm(inv(A)) is computed by a direct method, and the reciprocal of the condition number is computed as RCOND = 1 / (ANORM * norm(inv(A))).
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=sp), | intent(in) | :: | d(*) | |||
| real(kind=sp), | intent(in) | :: | e(*) | |||
| real(kind=sp), | intent(in) | :: | anorm | |||
| real(kind=sp), | intent(out) | :: | rcond | |||
| real(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
ZPTCON computes the reciprocal of the condition number (in the 1-norm) of a complex Hermitian positive definite tridiagonal matrix using the factorization A = LDLH or A = UHDU computed by ZPTTRF. Norm(inv(A)) is computed by a direct method, and the reciprocal of the condition number is computed as RCOND = 1 / (ANORM * norm(inv(A))).
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=dp), | intent(in) | :: | d(*) | |||
| complex(kind=dp), | intent(in) | :: | e(*) | |||
| real(kind=dp), | intent(in) | :: | anorm | |||
| real(kind=dp), | intent(out) | :: | rcond | |||
| real(kind=dp), | intent(out) | :: | rwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
PTEQR computes all eigenvalues and, optionally, eigenvectors of a symmetric positive definite tridiagonal matrix by first factoring the matrix using SPTTRF and then calling CBDSQR to compute the singular values of the bidiagonal factor. This routine computes the eigenvalues of the positive definite tridiagonal matrix to high relative accuracy. This means that if the eigenvalues range over many orders of magnitude in size, then the small eigenvalues and corresponding eigenvectors will be computed more accurately than, for example, with the standard QR method. The eigenvectors of a full or band positive definite Hermitian matrix can also be found if CHETRD, CHPTRD, or CHBTRD has been used to reduce this matrix to tridiagonal form. (The reduction to tridiagonal form, however, may preclude the possibility of obtaining high relative accuracy in the small eigenvalues of the original matrix, if these eigenvalues range over many orders of magnitude.)
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | compz | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=sp), | intent(inout) | :: | d(*) | |||
| real(kind=sp), | intent(inout) | :: | e(*) | |||
| complex(kind=sp), | intent(inout) | :: | z(ldz,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldz | |||
| real(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | compz | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=dp), | intent(inout) | :: | d(*) | |||
| real(kind=dp), | intent(inout) | :: | e(*) | |||
| real(kind=dp), | intent(inout) | :: | z(ldz,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldz | |||
| real(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | compz | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=sp), | intent(inout) | :: | d(*) | |||
| real(kind=sp), | intent(inout) | :: | e(*) | |||
| real(kind=sp), | intent(inout) | :: | z(ldz,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldz | |||
| real(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | compz | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=dp), | intent(inout) | :: | d(*) | |||
| real(kind=dp), | intent(inout) | :: | e(*) | |||
| complex(kind=dp), | intent(inout) | :: | z(ldz,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldz | |||
| real(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
CPTEQR computes all eigenvalues and, optionally, eigenvectors of a symmetric positive definite tridiagonal matrix by first factoring the matrix using SPTTRF and then calling CBDSQR to compute the singular values of the bidiagonal factor. This routine computes the eigenvalues of the positive definite tridiagonal matrix to high relative accuracy. This means that if the eigenvalues range over many orders of magnitude in size, then the small eigenvalues and corresponding eigenvectors will be computed more accurately than, for example, with the standard QR method. The eigenvectors of a full or band positive definite Hermitian matrix can also be found if CHETRD, CHPTRD, or CHBTRD has been used to reduce this matrix to tridiagonal form. (The reduction to tridiagonal form, however, may preclude the possibility of obtaining high relative accuracy in the small eigenvalues of the original matrix, if these eigenvalues range over many orders of magnitude.)
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | compz | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=sp), | intent(inout) | :: | d(*) | |||
| real(kind=sp), | intent(inout) | :: | e(*) | |||
| complex(kind=sp), | intent(inout) | :: | z(ldz,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldz | |||
| real(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
DPTEQR computes all eigenvalues and, optionally, eigenvectors of a symmetric positive definite tridiagonal matrix by first factoring the matrix using DPTTRF, and then calling DBDSQR to compute the singular values of the bidiagonal factor. This routine computes the eigenvalues of the positive definite tridiagonal matrix to high relative accuracy. This means that if the eigenvalues range over many orders of magnitude in size, then the small eigenvalues and corresponding eigenvectors will be computed more accurately than, for example, with the standard QR method. The eigenvectors of a full or band symmetric positive definite matrix can also be found if DSYTRD, DSPTRD, or DSBTRD has been used to reduce this matrix to tridiagonal form. (The reduction to tridiagonal form, however, may preclude the possibility of obtaining high relative accuracy in the small eigenvalues of the original matrix, if these eigenvalues range over many orders of magnitude.)
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | compz | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=dp), | intent(inout) | :: | d(*) | |||
| real(kind=dp), | intent(inout) | :: | e(*) | |||
| real(kind=dp), | intent(inout) | :: | z(ldz,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldz | |||
| real(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
SPTEQR computes all eigenvalues and, optionally, eigenvectors of a symmetric positive definite tridiagonal matrix by first factoring the matrix using SPTTRF, and then calling SBDSQR to compute the singular values of the bidiagonal factor. This routine computes the eigenvalues of the positive definite tridiagonal matrix to high relative accuracy. This means that if the eigenvalues range over many orders of magnitude in size, then the small eigenvalues and corresponding eigenvectors will be computed more accurately than, for example, with the standard QR method. The eigenvectors of a full or band symmetric positive definite matrix can also be found if SSYTRD, SSPTRD, or SSBTRD has been used to reduce this matrix to tridiagonal form. (The reduction to tridiagonal form, however, may preclude the possibility of obtaining high relative accuracy in the small eigenvalues of the original matrix, if these eigenvalues range over many orders of magnitude.)
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | compz | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=sp), | intent(inout) | :: | d(*) | |||
| real(kind=sp), | intent(inout) | :: | e(*) | |||
| real(kind=sp), | intent(inout) | :: | z(ldz,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldz | |||
| real(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
ZPTEQR computes all eigenvalues and, optionally, eigenvectors of a symmetric positive definite tridiagonal matrix by first factoring the matrix using DPTTRF and then calling ZBDSQR to compute the singular values of the bidiagonal factor. This routine computes the eigenvalues of the positive definite tridiagonal matrix to high relative accuracy. This means that if the eigenvalues range over many orders of magnitude in size, then the small eigenvalues and corresponding eigenvectors will be computed more accurately than, for example, with the standard QR method. The eigenvectors of a full or band positive definite Hermitian matrix can also be found if ZHETRD, ZHPTRD, or ZHBTRD has been used to reduce this matrix to tridiagonal form. (The reduction to tridiagonal form, however, may preclude the possibility of obtaining high relative accuracy in the small eigenvalues of the original matrix, if these eigenvalues range over many orders of magnitude.)
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | compz | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=dp), | intent(inout) | :: | d(*) | |||
| real(kind=dp), | intent(inout) | :: | e(*) | |||
| complex(kind=dp), | intent(inout) | :: | z(ldz,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldz | |||
| real(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
PTRFS improves the computed solution to a system of linear equations when the coefficient matrix is Hermitian positive definite and tridiagonal, and provides error bounds and backward error estimates for the solution.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| real(kind=sp), | intent(in) | :: | d(*) | |||
| complex(kind=sp), | intent(in) | :: | e(*) | |||
| real(kind=sp), | intent(in) | :: | df(*) | |||
| complex(kind=sp), | intent(in) | :: | ef(*) | |||
| complex(kind=sp), | intent(in) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| complex(kind=sp), | intent(inout) | :: | x(ldx,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldx | |||
| real(kind=sp), | intent(out) | :: | ferr(*) | |||
| real(kind=sp), | intent(out) | :: | berr(*) | |||
| complex(kind=sp), | intent(out) | :: | work(*) | |||
| real(kind=sp), | intent(out) | :: | rwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| real(kind=dp), | intent(in) | :: | d(*) | |||
| real(kind=dp), | intent(in) | :: | e(*) | |||
| real(kind=dp), | intent(in) | :: | df(*) | |||
| real(kind=dp), | intent(in) | :: | ef(*) | |||
| real(kind=dp), | intent(in) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| real(kind=dp), | intent(inout) | :: | x(ldx,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldx | |||
| real(kind=dp), | intent(out) | :: | ferr(*) | |||
| real(kind=dp), | intent(out) | :: | berr(*) | |||
| real(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| real(kind=sp), | intent(in) | :: | d(*) | |||
| real(kind=sp), | intent(in) | :: | e(*) | |||
| real(kind=sp), | intent(in) | :: | df(*) | |||
| real(kind=sp), | intent(in) | :: | ef(*) | |||
| real(kind=sp), | intent(in) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| real(kind=sp), | intent(inout) | :: | x(ldx,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldx | |||
| real(kind=sp), | intent(out) | :: | ferr(*) | |||
| real(kind=sp), | intent(out) | :: | berr(*) | |||
| real(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| real(kind=dp), | intent(in) | :: | d(*) | |||
| complex(kind=dp), | intent(in) | :: | e(*) | |||
| real(kind=dp), | intent(in) | :: | df(*) | |||
| complex(kind=dp), | intent(in) | :: | ef(*) | |||
| complex(kind=dp), | intent(in) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| complex(kind=dp), | intent(inout) | :: | x(ldx,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldx | |||
| real(kind=dp), | intent(out) | :: | ferr(*) | |||
| real(kind=dp), | intent(out) | :: | berr(*) | |||
| complex(kind=dp), | intent(out) | :: | work(*) | |||
| real(kind=dp), | intent(out) | :: | rwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
CPTRFS improves the computed solution to a system of linear equations when the coefficient matrix is Hermitian positive definite and tridiagonal, and provides error bounds and backward error estimates for the solution.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| real(kind=sp), | intent(in) | :: | d(*) | |||
| complex(kind=sp), | intent(in) | :: | e(*) | |||
| real(kind=sp), | intent(in) | :: | df(*) | |||
| complex(kind=sp), | intent(in) | :: | ef(*) | |||
| complex(kind=sp), | intent(in) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| complex(kind=sp), | intent(inout) | :: | x(ldx,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldx | |||
| real(kind=sp), | intent(out) | :: | ferr(*) | |||
| real(kind=sp), | intent(out) | :: | berr(*) | |||
| complex(kind=sp), | intent(out) | :: | work(*) | |||
| real(kind=sp), | intent(out) | :: | rwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
DPTRFS improves the computed solution to a system of linear equations when the coefficient matrix is symmetric positive definite and tridiagonal, and provides error bounds and backward error estimates for the solution.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| real(kind=dp), | intent(in) | :: | d(*) | |||
| real(kind=dp), | intent(in) | :: | e(*) | |||
| real(kind=dp), | intent(in) | :: | df(*) | |||
| real(kind=dp), | intent(in) | :: | ef(*) | |||
| real(kind=dp), | intent(in) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| real(kind=dp), | intent(inout) | :: | x(ldx,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldx | |||
| real(kind=dp), | intent(out) | :: | ferr(*) | |||
| real(kind=dp), | intent(out) | :: | berr(*) | |||
| real(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
SPTRFS improves the computed solution to a system of linear equations when the coefficient matrix is symmetric positive definite and tridiagonal, and provides error bounds and backward error estimates for the solution.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| real(kind=sp), | intent(in) | :: | d(*) | |||
| real(kind=sp), | intent(in) | :: | e(*) | |||
| real(kind=sp), | intent(in) | :: | df(*) | |||
| real(kind=sp), | intent(in) | :: | ef(*) | |||
| real(kind=sp), | intent(in) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| real(kind=sp), | intent(inout) | :: | x(ldx,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldx | |||
| real(kind=sp), | intent(out) | :: | ferr(*) | |||
| real(kind=sp), | intent(out) | :: | berr(*) | |||
| real(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
ZPTRFS improves the computed solution to a system of linear equations when the coefficient matrix is Hermitian positive definite and tridiagonal, and provides error bounds and backward error estimates for the solution.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| real(kind=dp), | intent(in) | :: | d(*) | |||
| complex(kind=dp), | intent(in) | :: | e(*) | |||
| real(kind=dp), | intent(in) | :: | df(*) | |||
| complex(kind=dp), | intent(in) | :: | ef(*) | |||
| complex(kind=dp), | intent(in) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| complex(kind=dp), | intent(inout) | :: | x(ldx,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldx | |||
| real(kind=dp), | intent(out) | :: | ferr(*) | |||
| real(kind=dp), | intent(out) | :: | berr(*) | |||
| complex(kind=dp), | intent(out) | :: | work(*) | |||
| real(kind=dp), | intent(out) | :: | rwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
PTSV computes the solution to a complex system of linear equations AX = B, where A is an N-by-N Hermitian positive definite tridiagonal matrix, and X and B are N-by-NRHS matrices. A is factored as A = LDL*H, and the factored form of A is then used to solve the system of equations.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| real(kind=sp), | intent(inout) | :: | d(*) | |||
| complex(kind=sp), | intent(inout) | :: | e(*) | |||
| complex(kind=sp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| real(kind=dp), | intent(inout) | :: | d(*) | |||
| real(kind=dp), | intent(inout) | :: | e(*) | |||
| real(kind=dp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| real(kind=sp), | intent(inout) | :: | d(*) | |||
| real(kind=sp), | intent(inout) | :: | e(*) | |||
| real(kind=sp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| real(kind=dp), | intent(inout) | :: | d(*) | |||
| complex(kind=dp), | intent(inout) | :: | e(*) | |||
| complex(kind=dp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| integer(kind=ilp), | intent(out) | :: | info |
CPTSV computes the solution to a complex system of linear equations AX = B, where A is an N-by-N Hermitian positive definite tridiagonal matrix, and X and B are N-by-NRHS matrices. A is factored as A = LDL*H, and the factored form of A is then used to solve the system of equations.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| real(kind=sp), | intent(inout) | :: | d(*) | |||
| complex(kind=sp), | intent(inout) | :: | e(*) | |||
| complex(kind=sp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| integer(kind=ilp), | intent(out) | :: | info |
DPTSV computes the solution to a real system of linear equations AX = B, where A is an N-by-N symmetric positive definite tridiagonal matrix, and X and B are N-by-NRHS matrices. A is factored as A = LDL*T, and the factored form of A is then used to solve the system of equations.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| real(kind=dp), | intent(inout) | :: | d(*) | |||
| real(kind=dp), | intent(inout) | :: | e(*) | |||
| real(kind=dp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| integer(kind=ilp), | intent(out) | :: | info |
SPTSV computes the solution to a real system of linear equations AX = B, where A is an N-by-N symmetric positive definite tridiagonal matrix, and X and B are N-by-NRHS matrices. A is factored as A = LDL*T, and the factored form of A is then used to solve the system of equations.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| real(kind=sp), | intent(inout) | :: | d(*) | |||
| real(kind=sp), | intent(inout) | :: | e(*) | |||
| real(kind=sp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| integer(kind=ilp), | intent(out) | :: | info |
ZPTSV computes the solution to a complex system of linear equations AX = B, where A is an N-by-N Hermitian positive definite tridiagonal matrix, and X and B are N-by-NRHS matrices. A is factored as A = LDL*H, and the factored form of A is then used to solve the system of equations.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| real(kind=dp), | intent(inout) | :: | d(*) | |||
| complex(kind=dp), | intent(inout) | :: | e(*) | |||
| complex(kind=dp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| integer(kind=ilp), | intent(out) | :: | info |
PTTRF computes the LDLH factorization of a complex Hermitian positive definite tridiagonal matrix A. The factorization may also be regarded as having the form A = UH DU.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=sp), | intent(inout) | :: | d(*) | |||
| complex(kind=sp), | intent(inout) | :: | e(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=dp), | intent(inout) | :: | d(*) | |||
| real(kind=dp), | intent(inout) | :: | e(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=sp), | intent(inout) | :: | d(*) | |||
| real(kind=sp), | intent(inout) | :: | e(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=dp), | intent(inout) | :: | d(*) | |||
| complex(kind=dp), | intent(inout) | :: | e(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
CPTTRF computes the LDLH factorization of a complex Hermitian positive definite tridiagonal matrix A. The factorization may also be regarded as having the form A = UH DU.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=sp), | intent(inout) | :: | d(*) | |||
| complex(kind=sp), | intent(inout) | :: | e(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
DPTTRF computes the LDLT factorization of a real symmetric positive definite tridiagonal matrix A. The factorization may also be regarded as having the form A = UTDU.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=dp), | intent(inout) | :: | d(*) | |||
| real(kind=dp), | intent(inout) | :: | e(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
SPTTRF computes the LDLT factorization of a real symmetric positive definite tridiagonal matrix A. The factorization may also be regarded as having the form A = UTDU.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=sp), | intent(inout) | :: | d(*) | |||
| real(kind=sp), | intent(inout) | :: | e(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
ZPTTRF computes the LDLH factorization of a complex Hermitian positive definite tridiagonal matrix A. The factorization may also be regarded as having the form A = UH DU.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=dp), | intent(inout) | :: | d(*) | |||
| complex(kind=dp), | intent(inout) | :: | e(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
PTTRS solves a tridiagonal system of the form A * X = B using the factorization A = UHDU or A = LDLH computed by CPTTRF. D is a diagonal matrix specified in the vector D, U (or L) is a unit bidiagonal matrix whose superdiagonal (subdiagonal) is specified in the vector E, and X and B are N by NRHS matrices.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| real(kind=sp), | intent(in) | :: | d(*) | |||
| complex(kind=sp), | intent(in) | :: | e(*) | |||
| complex(kind=sp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| real(kind=dp), | intent(in) | :: | d(*) | |||
| real(kind=dp), | intent(in) | :: | e(*) | |||
| real(kind=dp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| real(kind=sp), | intent(in) | :: | d(*) | |||
| real(kind=sp), | intent(in) | :: | e(*) | |||
| real(kind=sp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| real(kind=dp), | intent(in) | :: | d(*) | |||
| complex(kind=dp), | intent(in) | :: | e(*) | |||
| complex(kind=dp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| integer(kind=ilp), | intent(out) | :: | info |
CPTTRS solves a tridiagonal system of the form A * X = B using the factorization A = UHDU or A = LDLH computed by CPTTRF. D is a diagonal matrix specified in the vector D, U (or L) is a unit bidiagonal matrix whose superdiagonal (subdiagonal) is specified in the vector E, and X and B are N by NRHS matrices.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| real(kind=sp), | intent(in) | :: | d(*) | |||
| complex(kind=sp), | intent(in) | :: | e(*) | |||
| complex(kind=sp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| integer(kind=ilp), | intent(out) | :: | info |
DPTTRS solves a tridiagonal system of the form A * X = B using the LDL**T factorization of A computed by DPTTRF. D is a diagonal matrix specified in the vector D, L is a unit bidiagonal matrix whose subdiagonal is specified in the vector E, and X and B are N by NRHS matrices.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| real(kind=dp), | intent(in) | :: | d(*) | |||
| real(kind=dp), | intent(in) | :: | e(*) | |||
| real(kind=dp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| integer(kind=ilp), | intent(out) | :: | info |
SPTTRS solves a tridiagonal system of the form A * X = B using the LDL**T factorization of A computed by SPTTRF. D is a diagonal matrix specified in the vector D, L is a unit bidiagonal matrix whose subdiagonal is specified in the vector E, and X and B are N by NRHS matrices.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| real(kind=sp), | intent(in) | :: | d(*) | |||
| real(kind=sp), | intent(in) | :: | e(*) | |||
| real(kind=sp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| integer(kind=ilp), | intent(out) | :: | info |
ZPTTRS solves a tridiagonal system of the form A * X = B using the factorization A = UH D U or A = LDLH computed by ZPTTRF. D is a diagonal matrix specified in the vector D, U (or L) is a unit bidiagonal matrix whose superdiagonal (subdiagonal) is specified in the vector E, and X and B are N by NRHS matrices.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| real(kind=dp), | intent(in) | :: | d(*) | |||
| complex(kind=dp), | intent(in) | :: | e(*) | |||
| complex(kind=dp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| integer(kind=ilp), | intent(out) | :: | info |
ROT applies a plane rotation, where the cos (C) is real and the sin (S) is complex, and the vectors CX and CY are complex.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=sp), | intent(inout) | :: | cx(*) | |||
| integer(kind=ilp), | intent(in) | :: | incx | |||
| complex(kind=sp), | intent(inout) | :: | cy(*) | |||
| integer(kind=ilp), | intent(in) | :: | incy | |||
| real(kind=sp), | intent(in) | :: | c | |||
| complex(kind=sp), | intent(in) | :: | s |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=dp), | intent(inout) | :: | cx(*) | |||
| integer(kind=ilp), | intent(in) | :: | incx | |||
| complex(kind=dp), | intent(inout) | :: | cy(*) | |||
| integer(kind=ilp), | intent(in) | :: | incy | |||
| real(kind=dp), | intent(in) | :: | c | |||
| complex(kind=dp), | intent(in) | :: | s |
CROT applies a plane rotation, where the cos (C) is real and the sin (S) is complex, and the vectors CX and CY are complex.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=sp), | intent(inout) | :: | cx(*) | |||
| integer(kind=ilp), | intent(in) | :: | incx | |||
| complex(kind=sp), | intent(inout) | :: | cy(*) | |||
| integer(kind=ilp), | intent(in) | :: | incy | |||
| real(kind=sp), | intent(in) | :: | c | |||
| complex(kind=sp), | intent(in) | :: | s |
ZROT applies a plane rotation, where the cos (C) is real and the sin (S) is complex, and the vectors CX and CY are complex.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=dp), | intent(inout) | :: | cx(*) | |||
| integer(kind=ilp), | intent(in) | :: | incx | |||
| complex(kind=dp), | intent(inout) | :: | cy(*) | |||
| integer(kind=ilp), | intent(in) | :: | incy | |||
| real(kind=dp), | intent(in) | :: | c | |||
| complex(kind=dp), | intent(in) | :: | s |
RSCL multiplies an n-element real vector x by the real scalar 1/a. This is done without overflow or underflow as long as the final result x/a does not overflow or underflow.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=dp), | intent(in) | :: | sa | |||
| real(kind=dp), | intent(inout) | :: | sx(*) | |||
| integer(kind=ilp), | intent(in) | :: | incx |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=sp), | intent(in) | :: | sa | |||
| real(kind=sp), | intent(inout) | :: | sx(*) | |||
| integer(kind=ilp), | intent(in) | :: | incx |
DRSCL multiplies an n-element real vector x by the real scalar 1/a. This is done without overflow or underflow as long as the final result x/a does not overflow or underflow.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=dp), | intent(in) | :: | sa | |||
| real(kind=dp), | intent(inout) | :: | sx(*) | |||
| integer(kind=ilp), | intent(in) | :: | incx |
SRSCL multiplies an n-element real vector x by the real scalar 1/a. This is done without overflow or underflow as long as the final result x/a does not overflow or underflow.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=sp), | intent(in) | :: | sa | |||
| real(kind=sp), | intent(inout) | :: | sx(*) | |||
| integer(kind=ilp), | intent(in) | :: | incx |
SB2ST_KERNELS is an internal routine used by the DSYTRD_SB2ST subroutine.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| logical(kind=lk), | intent(in) | :: | wantz | |||
| integer(kind=ilp), | intent(in) | :: | ttype | |||
| integer(kind=ilp), | intent(in) | :: | st | |||
| integer(kind=ilp), | intent(in) | :: | ed | |||
| integer(kind=ilp), | intent(in) | :: | sweep | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nb | |||
| integer(kind=ilp), | intent(in) | :: | ib | |||
| real(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=dp), | intent(out) | :: | v(*) | |||
| real(kind=dp), | intent(out) | :: | tau(*) | |||
| integer(kind=ilp), | intent(in) | :: | ldvt | |||
| real(kind=dp), | intent(out) | :: | work(*) |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| logical(kind=lk), | intent(in) | :: | wantz | |||
| integer(kind=ilp), | intent(in) | :: | ttype | |||
| integer(kind=ilp), | intent(in) | :: | st | |||
| integer(kind=ilp), | intent(in) | :: | ed | |||
| integer(kind=ilp), | intent(in) | :: | sweep | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nb | |||
| integer(kind=ilp), | intent(in) | :: | ib | |||
| real(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=sp), | intent(out) | :: | v(*) | |||
| real(kind=sp), | intent(out) | :: | tau(*) | |||
| integer(kind=ilp), | intent(in) | :: | ldvt | |||
| real(kind=sp), | intent(out) | :: | work(*) |
DSB2ST_KERNELS is an internal routine used by the DSYTRD_SB2ST subroutine.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| logical(kind=lk), | intent(in) | :: | wantz | |||
| integer(kind=ilp), | intent(in) | :: | ttype | |||
| integer(kind=ilp), | intent(in) | :: | st | |||
| integer(kind=ilp), | intent(in) | :: | ed | |||
| integer(kind=ilp), | intent(in) | :: | sweep | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nb | |||
| integer(kind=ilp), | intent(in) | :: | ib | |||
| real(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=dp), | intent(out) | :: | v(*) | |||
| real(kind=dp), | intent(out) | :: | tau(*) | |||
| integer(kind=ilp), | intent(in) | :: | ldvt | |||
| real(kind=dp), | intent(out) | :: | work(*) |
SSB2ST_KERNELS is an internal routine used by the SSYTRD_SB2ST subroutine.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| logical(kind=lk), | intent(in) | :: | wantz | |||
| integer(kind=ilp), | intent(in) | :: | ttype | |||
| integer(kind=ilp), | intent(in) | :: | st | |||
| integer(kind=ilp), | intent(in) | :: | ed | |||
| integer(kind=ilp), | intent(in) | :: | sweep | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nb | |||
| integer(kind=ilp), | intent(in) | :: | ib | |||
| real(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=sp), | intent(out) | :: | v(*) | |||
| real(kind=sp), | intent(out) | :: | tau(*) | |||
| integer(kind=ilp), | intent(in) | :: | ldvt | |||
| real(kind=sp), | intent(out) | :: | work(*) |
SBEV computes all the eigenvalues and, optionally, eigenvectors of a real symmetric band matrix A.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | jobz | |||
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | kd | |||
| real(kind=dp), | intent(inout) | :: | ab(ldab,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldab | |||
| real(kind=dp), | intent(out) | :: | w(*) | |||
| real(kind=dp), | intent(out) | :: | z(ldz,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldz | |||
| real(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | jobz | |||
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | kd | |||
| real(kind=sp), | intent(inout) | :: | ab(ldab,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldab | |||
| real(kind=sp), | intent(out) | :: | w(*) | |||
| real(kind=sp), | intent(out) | :: | z(ldz,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldz | |||
| real(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
DSBEV computes all the eigenvalues and, optionally, eigenvectors of a real symmetric band matrix A.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | jobz | |||
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | kd | |||
| real(kind=dp), | intent(inout) | :: | ab(ldab,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldab | |||
| real(kind=dp), | intent(out) | :: | w(*) | |||
| real(kind=dp), | intent(out) | :: | z(ldz,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldz | |||
| real(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
SSBEV computes all the eigenvalues and, optionally, eigenvectors of a real symmetric band matrix A.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | jobz | |||
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | kd | |||
| real(kind=sp), | intent(inout) | :: | ab(ldab,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldab | |||
| real(kind=sp), | intent(out) | :: | w(*) | |||
| real(kind=sp), | intent(out) | :: | z(ldz,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldz | |||
| real(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
SBEVD computes all the eigenvalues and, optionally, eigenvectors of a real symmetric band matrix A. If eigenvectors are desired, it uses a divide and conquer algorithm. The divide and conquer algorithm makes very mild assumptions about floating point arithmetic. It will work on machines with a guard digit in add/subtract, or on those binary machines without guard digits which subtract like the Cray X-MP, Cray Y-MP, Cray C-90, or Cray-2. It could conceivably fail on hexadecimal or decimal machines without guard digits, but we know of none.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | jobz | |||
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | kd | |||
| real(kind=dp), | intent(inout) | :: | ab(ldab,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldab | |||
| real(kind=dp), | intent(out) | :: | w(*) | |||
| real(kind=dp), | intent(out) | :: | z(ldz,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldz | |||
| real(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | iwork(*) | |||
| integer(kind=ilp), | intent(in) | :: | liwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | jobz | |||
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | kd | |||
| real(kind=sp), | intent(inout) | :: | ab(ldab,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldab | |||
| real(kind=sp), | intent(out) | :: | w(*) | |||
| real(kind=sp), | intent(out) | :: | z(ldz,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldz | |||
| real(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | iwork(*) | |||
| integer(kind=ilp), | intent(in) | :: | liwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
DSBEVD computes all the eigenvalues and, optionally, eigenvectors of a real symmetric band matrix A. If eigenvectors are desired, it uses a divide and conquer algorithm. The divide and conquer algorithm makes very mild assumptions about floating point arithmetic. It will work on machines with a guard digit in add/subtract, or on those binary machines without guard digits which subtract like the Cray X-MP, Cray Y-MP, Cray C-90, or Cray-2. It could conceivably fail on hexadecimal or decimal machines without guard digits, but we know of none.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | jobz | |||
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | kd | |||
| real(kind=dp), | intent(inout) | :: | ab(ldab,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldab | |||
| real(kind=dp), | intent(out) | :: | w(*) | |||
| real(kind=dp), | intent(out) | :: | z(ldz,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldz | |||
| real(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | iwork(*) | |||
| integer(kind=ilp), | intent(in) | :: | liwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
SSBEVD computes all the eigenvalues and, optionally, eigenvectors of a real symmetric band matrix A. If eigenvectors are desired, it uses a divide and conquer algorithm. The divide and conquer algorithm makes very mild assumptions about floating point arithmetic. It will work on machines with a guard digit in add/subtract, or on those binary machines without guard digits which subtract like the Cray X-MP, Cray Y-MP, Cray C-90, or Cray-2. It could conceivably fail on hexadecimal or decimal machines without guard digits, but we know of none.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | jobz | |||
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | kd | |||
| real(kind=sp), | intent(inout) | :: | ab(ldab,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldab | |||
| real(kind=sp), | intent(out) | :: | w(*) | |||
| real(kind=sp), | intent(out) | :: | z(ldz,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldz | |||
| real(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | iwork(*) | |||
| integer(kind=ilp), | intent(in) | :: | liwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
SBGST reduces a real symmetric-definite banded generalized eigenproblem Ax = lambdaBx to standard form Cy = lambday, such that C has the same bandwidth as A. B must have been previously factorized as STS by DPBSTF, using a split Cholesky factorization. A is overwritten by C = XTAX, where X = S(-1)*Q and Q is an orthogonal matrix chosen to preserve the bandwidth of A.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | vect | |||
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | ka | |||
| integer(kind=ilp), | intent(in) | :: | kb | |||
| real(kind=dp), | intent(inout) | :: | ab(ldab,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldab | |||
| real(kind=dp), | intent(in) | :: | bb(ldbb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldbb | |||
| real(kind=dp), | intent(out) | :: | x(ldx,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldx | |||
| real(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | vect | |||
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | ka | |||
| integer(kind=ilp), | intent(in) | :: | kb | |||
| real(kind=sp), | intent(inout) | :: | ab(ldab,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldab | |||
| real(kind=sp), | intent(in) | :: | bb(ldbb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldbb | |||
| real(kind=sp), | intent(out) | :: | x(ldx,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldx | |||
| real(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
DSBGST reduces a real symmetric-definite banded generalized eigenproblem Ax = lambdaBx to standard form Cy = lambday, such that C has the same bandwidth as A. B must have been previously factorized as STS by DPBSTF, using a split Cholesky factorization. A is overwritten by C = XTAX, where X = S(-1)*Q and Q is an orthogonal matrix chosen to preserve the bandwidth of A.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | vect | |||
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | ka | |||
| integer(kind=ilp), | intent(in) | :: | kb | |||
| real(kind=dp), | intent(inout) | :: | ab(ldab,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldab | |||
| real(kind=dp), | intent(in) | :: | bb(ldbb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldbb | |||
| real(kind=dp), | intent(out) | :: | x(ldx,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldx | |||
| real(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
SSBGST reduces a real symmetric-definite banded generalized eigenproblem Ax = lambdaBx to standard form Cy = lambday, such that C has the same bandwidth as A. B must have been previously factorized as STS by SPBSTF, using a split Cholesky factorization. A is overwritten by C = XTAX, where X = S(-1)*Q and Q is an orthogonal matrix chosen to preserve the bandwidth of A.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | vect | |||
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | ka | |||
| integer(kind=ilp), | intent(in) | :: | kb | |||
| real(kind=sp), | intent(inout) | :: | ab(ldab,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldab | |||
| real(kind=sp), | intent(in) | :: | bb(ldbb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldbb | |||
| real(kind=sp), | intent(out) | :: | x(ldx,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldx | |||
| real(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
SBGV computes all the eigenvalues, and optionally, the eigenvectors of a real generalized symmetric-definite banded eigenproblem, of the form Ax=(lambda)B*x. Here A and B are assumed to be symmetric and banded, and B is also positive definite.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | jobz | |||
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | ka | |||
| integer(kind=ilp), | intent(in) | :: | kb | |||
| real(kind=dp), | intent(inout) | :: | ab(ldab,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldab | |||
| real(kind=dp), | intent(inout) | :: | bb(ldbb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldbb | |||
| real(kind=dp), | intent(out) | :: | w(*) | |||
| real(kind=dp), | intent(out) | :: | z(ldz,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldz | |||
| real(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | jobz | |||
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | ka | |||
| integer(kind=ilp), | intent(in) | :: | kb | |||
| real(kind=sp), | intent(inout) | :: | ab(ldab,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldab | |||
| real(kind=sp), | intent(inout) | :: | bb(ldbb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldbb | |||
| real(kind=sp), | intent(out) | :: | w(*) | |||
| real(kind=sp), | intent(out) | :: | z(ldz,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldz | |||
| real(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
DSBGV computes all the eigenvalues, and optionally, the eigenvectors of a real generalized symmetric-definite banded eigenproblem, of the form Ax=(lambda)B*x. Here A and B are assumed to be symmetric and banded, and B is also positive definite.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | jobz | |||
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | ka | |||
| integer(kind=ilp), | intent(in) | :: | kb | |||
| real(kind=dp), | intent(inout) | :: | ab(ldab,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldab | |||
| real(kind=dp), | intent(inout) | :: | bb(ldbb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldbb | |||
| real(kind=dp), | intent(out) | :: | w(*) | |||
| real(kind=dp), | intent(out) | :: | z(ldz,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldz | |||
| real(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
SSBGV computes all the eigenvalues, and optionally, the eigenvectors of a real generalized symmetric-definite banded eigenproblem, of the form Ax=(lambda)B*x. Here A and B are assumed to be symmetric and banded, and B is also positive definite.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | jobz | |||
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | ka | |||
| integer(kind=ilp), | intent(in) | :: | kb | |||
| real(kind=sp), | intent(inout) | :: | ab(ldab,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldab | |||
| real(kind=sp), | intent(inout) | :: | bb(ldbb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldbb | |||
| real(kind=sp), | intent(out) | :: | w(*) | |||
| real(kind=sp), | intent(out) | :: | z(ldz,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldz | |||
| real(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
SBGVD computes all the eigenvalues, and optionally, the eigenvectors of a real generalized symmetric-definite banded eigenproblem, of the form Ax=(lambda)B*x. Here A and B are assumed to be symmetric and banded, and B is also positive definite. If eigenvectors are desired, it uses a divide and conquer algorithm. The divide and conquer algorithm makes very mild assumptions about floating point arithmetic. It will work on machines with a guard digit in add/subtract, or on those binary machines without guard digits which subtract like the Cray X-MP, Cray Y-MP, Cray C-90, or Cray-2. It could conceivably fail on hexadecimal or decimal machines without guard digits, but we know of none.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | jobz | |||
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | ka | |||
| integer(kind=ilp), | intent(in) | :: | kb | |||
| real(kind=dp), | intent(inout) | :: | ab(ldab,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldab | |||
| real(kind=dp), | intent(inout) | :: | bb(ldbb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldbb | |||
| real(kind=dp), | intent(out) | :: | w(*) | |||
| real(kind=dp), | intent(out) | :: | z(ldz,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldz | |||
| real(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | iwork(*) | |||
| integer(kind=ilp), | intent(in) | :: | liwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | jobz | |||
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | ka | |||
| integer(kind=ilp), | intent(in) | :: | kb | |||
| real(kind=sp), | intent(inout) | :: | ab(ldab,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldab | |||
| real(kind=sp), | intent(inout) | :: | bb(ldbb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldbb | |||
| real(kind=sp), | intent(out) | :: | w(*) | |||
| real(kind=sp), | intent(out) | :: | z(ldz,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldz | |||
| real(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | iwork(*) | |||
| integer(kind=ilp), | intent(in) | :: | liwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
DSBGVD computes all the eigenvalues, and optionally, the eigenvectors of a real generalized symmetric-definite banded eigenproblem, of the form Ax=(lambda)B*x. Here A and B are assumed to be symmetric and banded, and B is also positive definite. If eigenvectors are desired, it uses a divide and conquer algorithm. The divide and conquer algorithm makes very mild assumptions about floating point arithmetic. It will work on machines with a guard digit in add/subtract, or on those binary machines without guard digits which subtract like the Cray X-MP, Cray Y-MP, Cray C-90, or Cray-2. It could conceivably fail on hexadecimal or decimal machines without guard digits, but we know of none.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | jobz | |||
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | ka | |||
| integer(kind=ilp), | intent(in) | :: | kb | |||
| real(kind=dp), | intent(inout) | :: | ab(ldab,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldab | |||
| real(kind=dp), | intent(inout) | :: | bb(ldbb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldbb | |||
| real(kind=dp), | intent(out) | :: | w(*) | |||
| real(kind=dp), | intent(out) | :: | z(ldz,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldz | |||
| real(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | iwork(*) | |||
| integer(kind=ilp), | intent(in) | :: | liwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
SSBGVD computes all the eigenvalues, and optionally, the eigenvectors of a real generalized symmetric-definite banded eigenproblem, of the form Ax=(lambda)B*x. Here A and B are assumed to be symmetric and banded, and B is also positive definite. If eigenvectors are desired, it uses a divide and conquer algorithm. The divide and conquer algorithm makes very mild assumptions about floating point arithmetic. It will work on machines with a guard digit in add/subtract, or on those binary machines without guard digits which subtract like the Cray X-MP, Cray Y-MP, Cray C-90, or Cray-2. It could conceivably fail on hexadecimal or decimal machines without guard digits, but we know of none.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | jobz | |||
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | ka | |||
| integer(kind=ilp), | intent(in) | :: | kb | |||
| real(kind=sp), | intent(inout) | :: | ab(ldab,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldab | |||
| real(kind=sp), | intent(inout) | :: | bb(ldbb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldbb | |||
| real(kind=sp), | intent(out) | :: | w(*) | |||
| real(kind=sp), | intent(out) | :: | z(ldz,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldz | |||
| real(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | iwork(*) | |||
| integer(kind=ilp), | intent(in) | :: | liwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
SBTRD reduces a real symmetric band matrix A to symmetric tridiagonal form T by an orthogonal similarity transformation: Q**T * A * Q = T.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | vect | |||
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | kd | |||
| real(kind=dp), | intent(inout) | :: | ab(ldab,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldab | |||
| real(kind=dp), | intent(out) | :: | d(*) | |||
| real(kind=dp), | intent(out) | :: | e(*) | |||
| real(kind=dp), | intent(inout) | :: | q(ldq,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldq | |||
| real(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | vect | |||
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | kd | |||
| real(kind=sp), | intent(inout) | :: | ab(ldab,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldab | |||
| real(kind=sp), | intent(out) | :: | d(*) | |||
| real(kind=sp), | intent(out) | :: | e(*) | |||
| real(kind=sp), | intent(inout) | :: | q(ldq,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldq | |||
| real(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
DSBTRD reduces a real symmetric band matrix A to symmetric tridiagonal form T by an orthogonal similarity transformation: Q**T * A * Q = T.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | vect | |||
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | kd | |||
| real(kind=dp), | intent(inout) | :: | ab(ldab,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldab | |||
| real(kind=dp), | intent(out) | :: | d(*) | |||
| real(kind=dp), | intent(out) | :: | e(*) | |||
| real(kind=dp), | intent(inout) | :: | q(ldq,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldq | |||
| real(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
SSBTRD reduces a real symmetric band matrix A to symmetric tridiagonal form T by an orthogonal similarity transformation: Q**T * A * Q = T.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | vect | |||
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | kd | |||
| real(kind=sp), | intent(inout) | :: | ab(ldab,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldab | |||
| real(kind=sp), | intent(out) | :: | d(*) | |||
| real(kind=sp), | intent(out) | :: | e(*) | |||
| real(kind=sp), | intent(inout) | :: | q(ldq,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldq | |||
| real(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
Level 3 BLAS like routine for C in RFP Format. SFRK performs one of the symmetric rank--k operations C := alphaAAT + betaC, or C := alphaATA + betaC, where alpha and beta are real scalars, C is an n--by--n symmetric matrix and A is an n--by--k matrix in the first case and a k--by--n matrix in the second case.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | transr | |||
| character, | intent(in) | :: | uplo | |||
| character, | intent(in) | :: | trans | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | k | |||
| real(kind=dp), | intent(in) | :: | alpha | |||
| real(kind=dp), | intent(in) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=dp), | intent(in) | :: | beta | |||
| real(kind=dp), | intent(inout) | :: | c(*) |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | transr | |||
| character, | intent(in) | :: | uplo | |||
| character, | intent(in) | :: | trans | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | k | |||
| real(kind=sp), | intent(in) | :: | alpha | |||
| real(kind=sp), | intent(in) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=sp), | intent(in) | :: | beta | |||
| real(kind=sp), | intent(inout) | :: | c(*) |
Level 3 BLAS like routine for C in RFP Format. DSFRK performs one of the symmetric rank--k operations C := alphaAAT + betaC, or C := alphaATA + betaC, where alpha and beta are real scalars, C is an n--by--n symmetric matrix and A is an n--by--k matrix in the first case and a k--by--n matrix in the second case.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | transr | |||
| character, | intent(in) | :: | uplo | |||
| character, | intent(in) | :: | trans | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | k | |||
| real(kind=dp), | intent(in) | :: | alpha | |||
| real(kind=dp), | intent(in) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=dp), | intent(in) | :: | beta | |||
| real(kind=dp), | intent(inout) | :: | c(*) |
Level 3 BLAS like routine for C in RFP Format. SSFRK performs one of the symmetric rank--k operations C := alphaAAT + betaC, or C := alphaATA + betaC, where alpha and beta are real scalars, C is an n--by--n symmetric matrix and A is an n--by--k matrix in the first case and a k--by--n matrix in the second case.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | transr | |||
| character, | intent(in) | :: | uplo | |||
| character, | intent(in) | :: | trans | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | k | |||
| real(kind=sp), | intent(in) | :: | alpha | |||
| real(kind=sp), | intent(in) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=sp), | intent(in) | :: | beta | |||
| real(kind=sp), | intent(inout) | :: | c(*) |
SPCON estimates the reciprocal of the condition number (in the 1-norm) of a complex symmetric packed matrix A using the factorization A = UDUT or A = LDLT computed by CSPTRF. An estimate is obtained for norm(inv(A)), and the reciprocal of the condition number is computed as RCOND = 1 / (ANORM * norm(inv(A))).
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=sp), | intent(in) | :: | ap(*) | |||
| integer(kind=ilp), | intent(in) | :: | ipiv(*) | |||
| real(kind=sp), | intent(in) | :: | anorm | |||
| real(kind=sp), | intent(out) | :: | rcond | |||
| complex(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=dp), | intent(in) | :: | ap(*) | |||
| integer(kind=ilp), | intent(in) | :: | ipiv(*) | |||
| real(kind=dp), | intent(in) | :: | anorm | |||
| real(kind=dp), | intent(out) | :: | rcond | |||
| real(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | iwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=sp), | intent(in) | :: | ap(*) | |||
| integer(kind=ilp), | intent(in) | :: | ipiv(*) | |||
| real(kind=sp), | intent(in) | :: | anorm | |||
| real(kind=sp), | intent(out) | :: | rcond | |||
| real(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | iwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=dp), | intent(in) | :: | ap(*) | |||
| integer(kind=ilp), | intent(in) | :: | ipiv(*) | |||
| real(kind=dp), | intent(in) | :: | anorm | |||
| real(kind=dp), | intent(out) | :: | rcond | |||
| complex(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
CSPCON estimates the reciprocal of the condition number (in the 1-norm) of a complex symmetric packed matrix A using the factorization A = UDUT or A = LDLT computed by CSPTRF. An estimate is obtained for norm(inv(A)), and the reciprocal of the condition number is computed as RCOND = 1 / (ANORM * norm(inv(A))).
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=sp), | intent(in) | :: | ap(*) | |||
| integer(kind=ilp), | intent(in) | :: | ipiv(*) | |||
| real(kind=sp), | intent(in) | :: | anorm | |||
| real(kind=sp), | intent(out) | :: | rcond | |||
| complex(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
DSPCON estimates the reciprocal of the condition number (in the 1-norm) of a real symmetric packed matrix A using the factorization A = UDUT or A = LDLT computed by DSPTRF. An estimate is obtained for norm(inv(A)), and the reciprocal of the condition number is computed as RCOND = 1 / (ANORM * norm(inv(A))).
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=dp), | intent(in) | :: | ap(*) | |||
| integer(kind=ilp), | intent(in) | :: | ipiv(*) | |||
| real(kind=dp), | intent(in) | :: | anorm | |||
| real(kind=dp), | intent(out) | :: | rcond | |||
| real(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | iwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
SSPCON estimates the reciprocal of the condition number (in the 1-norm) of a real symmetric packed matrix A using the factorization A = UDUT or A = LDLT computed by SSPTRF. An estimate is obtained for norm(inv(A)), and the reciprocal of the condition number is computed as RCOND = 1 / (ANORM * norm(inv(A))).
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=sp), | intent(in) | :: | ap(*) | |||
| integer(kind=ilp), | intent(in) | :: | ipiv(*) | |||
| real(kind=sp), | intent(in) | :: | anorm | |||
| real(kind=sp), | intent(out) | :: | rcond | |||
| real(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | iwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
ZSPCON estimates the reciprocal of the condition number (in the 1-norm) of a complex symmetric packed matrix A using the factorization A = UDUT or A = LDLT computed by ZSPTRF. An estimate is obtained for norm(inv(A)), and the reciprocal of the condition number is computed as RCOND = 1 / (ANORM * norm(inv(A))).
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=dp), | intent(in) | :: | ap(*) | |||
| integer(kind=ilp), | intent(in) | :: | ipiv(*) | |||
| real(kind=dp), | intent(in) | :: | anorm | |||
| real(kind=dp), | intent(out) | :: | rcond | |||
| complex(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
SPEV computes all the eigenvalues and, optionally, eigenvectors of a real symmetric matrix A in packed storage.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | jobz | |||
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=dp), | intent(inout) | :: | ap(*) | |||
| real(kind=dp), | intent(out) | :: | w(*) | |||
| real(kind=dp), | intent(out) | :: | z(ldz,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldz | |||
| real(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | jobz | |||
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=sp), | intent(inout) | :: | ap(*) | |||
| real(kind=sp), | intent(out) | :: | w(*) | |||
| real(kind=sp), | intent(out) | :: | z(ldz,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldz | |||
| real(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
DSPEV computes all the eigenvalues and, optionally, eigenvectors of a real symmetric matrix A in packed storage.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | jobz | |||
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=dp), | intent(inout) | :: | ap(*) | |||
| real(kind=dp), | intent(out) | :: | w(*) | |||
| real(kind=dp), | intent(out) | :: | z(ldz,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldz | |||
| real(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
SSPEV computes all the eigenvalues and, optionally, eigenvectors of a real symmetric matrix A in packed storage.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | jobz | |||
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=sp), | intent(inout) | :: | ap(*) | |||
| real(kind=sp), | intent(out) | :: | w(*) | |||
| real(kind=sp), | intent(out) | :: | z(ldz,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldz | |||
| real(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
SPEVD computes all the eigenvalues and, optionally, eigenvectors of a real symmetric matrix A in packed storage. If eigenvectors are desired, it uses a divide and conquer algorithm. The divide and conquer algorithm makes very mild assumptions about floating point arithmetic. It will work on machines with a guard digit in add/subtract, or on those binary machines without guard digits which subtract like the Cray X-MP, Cray Y-MP, Cray C-90, or Cray-2. It could conceivably fail on hexadecimal or decimal machines without guard digits, but we know of none.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | jobz | |||
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=dp), | intent(inout) | :: | ap(*) | |||
| real(kind=dp), | intent(out) | :: | w(*) | |||
| real(kind=dp), | intent(out) | :: | z(ldz,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldz | |||
| real(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | iwork(*) | |||
| integer(kind=ilp), | intent(in) | :: | liwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | jobz | |||
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=sp), | intent(inout) | :: | ap(*) | |||
| real(kind=sp), | intent(out) | :: | w(*) | |||
| real(kind=sp), | intent(out) | :: | z(ldz,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldz | |||
| real(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | iwork(*) | |||
| integer(kind=ilp), | intent(in) | :: | liwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
DSPEVD computes all the eigenvalues and, optionally, eigenvectors of a real symmetric matrix A in packed storage. If eigenvectors are desired, it uses a divide and conquer algorithm. The divide and conquer algorithm makes very mild assumptions about floating point arithmetic. It will work on machines with a guard digit in add/subtract, or on those binary machines without guard digits which subtract like the Cray X-MP, Cray Y-MP, Cray C-90, or Cray-2. It could conceivably fail on hexadecimal or decimal machines without guard digits, but we know of none.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | jobz | |||
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=dp), | intent(inout) | :: | ap(*) | |||
| real(kind=dp), | intent(out) | :: | w(*) | |||
| real(kind=dp), | intent(out) | :: | z(ldz,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldz | |||
| real(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | iwork(*) | |||
| integer(kind=ilp), | intent(in) | :: | liwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
SSPEVD computes all the eigenvalues and, optionally, eigenvectors of a real symmetric matrix A in packed storage. If eigenvectors are desired, it uses a divide and conquer algorithm. The divide and conquer algorithm makes very mild assumptions about floating point arithmetic. It will work on machines with a guard digit in add/subtract, or on those binary machines without guard digits which subtract like the Cray X-MP, Cray Y-MP, Cray C-90, or Cray-2. It could conceivably fail on hexadecimal or decimal machines without guard digits, but we know of none.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | jobz | |||
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=sp), | intent(inout) | :: | ap(*) | |||
| real(kind=sp), | intent(out) | :: | w(*) | |||
| real(kind=sp), | intent(out) | :: | z(ldz,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldz | |||
| real(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | iwork(*) | |||
| integer(kind=ilp), | intent(in) | :: | liwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
SPGST reduces a real symmetric-definite generalized eigenproblem to standard form, using packed storage. If ITYPE = 1, the problem is Ax = lambdaBx, and A is overwritten by inv(UT)Ainv(U) or inv(L)Ainv(LT) If ITYPE = 2 or 3, the problem is ABx = lambdax or BAx = lambdax, and A is overwritten by UAUT or LTAL. B must have been previously factorized as UTU or LL*T by DPPTRF.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | itype | |||
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=dp), | intent(inout) | :: | ap(*) | |||
| real(kind=dp), | intent(in) | :: | bp(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | itype | |||
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=sp), | intent(inout) | :: | ap(*) | |||
| real(kind=sp), | intent(in) | :: | bp(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
DSPGST reduces a real symmetric-definite generalized eigenproblem to standard form, using packed storage. If ITYPE = 1, the problem is Ax = lambdaBx, and A is overwritten by inv(UT)Ainv(U) or inv(L)Ainv(LT) If ITYPE = 2 or 3, the problem is ABx = lambdax or BAx = lambdax, and A is overwritten by UAUT or LTAL. B must have been previously factorized as UTU or LL*T by DPPTRF.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | itype | |||
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=dp), | intent(inout) | :: | ap(*) | |||
| real(kind=dp), | intent(in) | :: | bp(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
SSPGST reduces a real symmetric-definite generalized eigenproblem to standard form, using packed storage. If ITYPE = 1, the problem is Ax = lambdaBx, and A is overwritten by inv(UT)Ainv(U) or inv(L)Ainv(LT) If ITYPE = 2 or 3, the problem is ABx = lambdax or BAx = lambdax, and A is overwritten by UAUT or LTAL. B must have been previously factorized as UTU or LL*T by SPPTRF.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | itype | |||
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=sp), | intent(inout) | :: | ap(*) | |||
| real(kind=sp), | intent(in) | :: | bp(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
SPGV computes all the eigenvalues and, optionally, the eigenvectors of a real generalized symmetric-definite eigenproblem, of the form Ax=(lambda)Bx, ABx=(lambda)x, or BAx=(lambda)x. Here A and B are assumed to be symmetric, stored in packed format, and B is also positive definite.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | itype | |||
| character, | intent(in) | :: | jobz | |||
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=dp), | intent(inout) | :: | ap(*) | |||
| real(kind=dp), | intent(inout) | :: | bp(*) | |||
| real(kind=dp), | intent(out) | :: | w(*) | |||
| real(kind=dp), | intent(out) | :: | z(ldz,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldz | |||
| real(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | itype | |||
| character, | intent(in) | :: | jobz | |||
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=sp), | intent(inout) | :: | ap(*) | |||
| real(kind=sp), | intent(inout) | :: | bp(*) | |||
| real(kind=sp), | intent(out) | :: | w(*) | |||
| real(kind=sp), | intent(out) | :: | z(ldz,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldz | |||
| real(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
DSPGV computes all the eigenvalues and, optionally, the eigenvectors of a real generalized symmetric-definite eigenproblem, of the form Ax=(lambda)Bx, ABx=(lambda)x, or BAx=(lambda)x. Here A and B are assumed to be symmetric, stored in packed format, and B is also positive definite.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | itype | |||
| character, | intent(in) | :: | jobz | |||
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=dp), | intent(inout) | :: | ap(*) | |||
| real(kind=dp), | intent(inout) | :: | bp(*) | |||
| real(kind=dp), | intent(out) | :: | w(*) | |||
| real(kind=dp), | intent(out) | :: | z(ldz,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldz | |||
| real(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
SSPGV computes all the eigenvalues and, optionally, the eigenvectors of a real generalized symmetric-definite eigenproblem, of the form Ax=(lambda)Bx, ABx=(lambda)x, or BAx=(lambda)x. Here A and B are assumed to be symmetric, stored in packed format, and B is also positive definite.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | itype | |||
| character, | intent(in) | :: | jobz | |||
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=sp), | intent(inout) | :: | ap(*) | |||
| real(kind=sp), | intent(inout) | :: | bp(*) | |||
| real(kind=sp), | intent(out) | :: | w(*) | |||
| real(kind=sp), | intent(out) | :: | z(ldz,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldz | |||
| real(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
SPGVD computes all the eigenvalues, and optionally, the eigenvectors of a real generalized symmetric-definite eigenproblem, of the form Ax=(lambda)Bx, ABx=(lambda)x, or BAx=(lambda)x. Here A and B are assumed to be symmetric, stored in packed format, and B is also positive definite. If eigenvectors are desired, it uses a divide and conquer algorithm. The divide and conquer algorithm makes very mild assumptions about floating point arithmetic. It will work on machines with a guard digit in add/subtract, or on those binary machines without guard digits which subtract like the Cray X-MP, Cray Y-MP, Cray C-90, or Cray-2. It could conceivably fail on hexadecimal or decimal machines without guard digits, but we know of none.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | itype | |||
| character, | intent(in) | :: | jobz | |||
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=dp), | intent(inout) | :: | ap(*) | |||
| real(kind=dp), | intent(inout) | :: | bp(*) | |||
| real(kind=dp), | intent(out) | :: | w(*) | |||
| real(kind=dp), | intent(out) | :: | z(ldz,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldz | |||
| real(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | iwork(*) | |||
| integer(kind=ilp), | intent(in) | :: | liwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | itype | |||
| character, | intent(in) | :: | jobz | |||
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=sp), | intent(inout) | :: | ap(*) | |||
| real(kind=sp), | intent(inout) | :: | bp(*) | |||
| real(kind=sp), | intent(out) | :: | w(*) | |||
| real(kind=sp), | intent(out) | :: | z(ldz,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldz | |||
| real(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | iwork(*) | |||
| integer(kind=ilp), | intent(in) | :: | liwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
DSPGVD computes all the eigenvalues, and optionally, the eigenvectors of a real generalized symmetric-definite eigenproblem, of the form Ax=(lambda)Bx, ABx=(lambda)x, or BAx=(lambda)x. Here A and B are assumed to be symmetric, stored in packed format, and B is also positive definite. If eigenvectors are desired, it uses a divide and conquer algorithm. The divide and conquer algorithm makes very mild assumptions about floating point arithmetic. It will work on machines with a guard digit in add/subtract, or on those binary machines without guard digits which subtract like the Cray X-MP, Cray Y-MP, Cray C-90, or Cray-2. It could conceivably fail on hexadecimal or decimal machines without guard digits, but we know of none.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | itype | |||
| character, | intent(in) | :: | jobz | |||
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=dp), | intent(inout) | :: | ap(*) | |||
| real(kind=dp), | intent(inout) | :: | bp(*) | |||
| real(kind=dp), | intent(out) | :: | w(*) | |||
| real(kind=dp), | intent(out) | :: | z(ldz,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldz | |||
| real(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | iwork(*) | |||
| integer(kind=ilp), | intent(in) | :: | liwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
SSPGVD computes all the eigenvalues, and optionally, the eigenvectors of a real generalized symmetric-definite eigenproblem, of the form Ax=(lambda)Bx, ABx=(lambda)x, or BAx=(lambda)x. Here A and B are assumed to be symmetric, stored in packed format, and B is also positive definite. If eigenvectors are desired, it uses a divide and conquer algorithm. The divide and conquer algorithm makes very mild assumptions about floating point arithmetic. It will work on machines with a guard digit in add/subtract, or on those binary machines without guard digits which subtract like the Cray X-MP, Cray Y-MP, Cray C-90, or Cray-2. It could conceivably fail on hexadecimal or decimal machines without guard digits, but we know of none.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | itype | |||
| character, | intent(in) | :: | jobz | |||
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=sp), | intent(inout) | :: | ap(*) | |||
| real(kind=sp), | intent(inout) | :: | bp(*) | |||
| real(kind=sp), | intent(out) | :: | w(*) | |||
| real(kind=sp), | intent(out) | :: | z(ldz,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldz | |||
| real(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | iwork(*) | |||
| integer(kind=ilp), | intent(in) | :: | liwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
SPMV performs the matrix-vector operation y := alphaAx + beta*y, where alpha and beta are scalars, x and y are n element vectors and A is an n by n symmetric matrix, supplied in packed form.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=sp), | intent(in) | :: | alpha | |||
| complex(kind=sp), | intent(in) | :: | ap(*) | |||
| complex(kind=sp), | intent(in) | :: | x(*) | |||
| integer(kind=ilp), | intent(in) | :: | incx | |||
| complex(kind=sp), | intent(in) | :: | beta | |||
| complex(kind=sp), | intent(inout) | :: | y(*) | |||
| integer(kind=ilp), | intent(in) | :: | incy |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=dp), | intent(in) | :: | alpha | |||
| complex(kind=dp), | intent(in) | :: | ap(*) | |||
| complex(kind=dp), | intent(in) | :: | x(*) | |||
| integer(kind=ilp), | intent(in) | :: | incx | |||
| complex(kind=dp), | intent(in) | :: | beta | |||
| complex(kind=dp), | intent(inout) | :: | y(*) | |||
| integer(kind=ilp), | intent(in) | :: | incy |
CSPMV performs the matrix-vector operation y := alphaAx + beta*y, where alpha and beta are scalars, x and y are n element vectors and A is an n by n symmetric matrix, supplied in packed form.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=sp), | intent(in) | :: | alpha | |||
| complex(kind=sp), | intent(in) | :: | ap(*) | |||
| complex(kind=sp), | intent(in) | :: | x(*) | |||
| integer(kind=ilp), | intent(in) | :: | incx | |||
| complex(kind=sp), | intent(in) | :: | beta | |||
| complex(kind=sp), | intent(inout) | :: | y(*) | |||
| integer(kind=ilp), | intent(in) | :: | incy |
ZSPMV performs the matrix-vector operation y := alphaAx + beta*y, where alpha and beta are scalars, x and y are n element vectors and A is an n by n symmetric matrix, supplied in packed form.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=dp), | intent(in) | :: | alpha | |||
| complex(kind=dp), | intent(in) | :: | ap(*) | |||
| complex(kind=dp), | intent(in) | :: | x(*) | |||
| integer(kind=ilp), | intent(in) | :: | incx | |||
| complex(kind=dp), | intent(in) | :: | beta | |||
| complex(kind=dp), | intent(inout) | :: | y(*) | |||
| integer(kind=ilp), | intent(in) | :: | incy |
SPR performs the symmetric rank 1 operation A := alphaxx**H + A, where alpha is a complex scalar, x is an n element vector and A is an n by n symmetric matrix, supplied in packed form.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=sp), | intent(in) | :: | alpha | |||
| complex(kind=sp), | intent(in) | :: | x(*) | |||
| integer(kind=ilp), | intent(in) | :: | incx | |||
| complex(kind=sp), | intent(inout) | :: | ap(*) |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=dp), | intent(in) | :: | alpha | |||
| complex(kind=dp), | intent(in) | :: | x(*) | |||
| integer(kind=ilp), | intent(in) | :: | incx | |||
| complex(kind=dp), | intent(inout) | :: | ap(*) |
CSPR performs the symmetric rank 1 operation A := alphaxx**H + A, where alpha is a complex scalar, x is an n element vector and A is an n by n symmetric matrix, supplied in packed form.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=sp), | intent(in) | :: | alpha | |||
| complex(kind=sp), | intent(in) | :: | x(*) | |||
| integer(kind=ilp), | intent(in) | :: | incx | |||
| complex(kind=sp), | intent(inout) | :: | ap(*) |
ZSPR performs the symmetric rank 1 operation A := alphaxx**H + A, where alpha is a complex scalar, x is an n element vector and A is an n by n symmetric matrix, supplied in packed form.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=dp), | intent(in) | :: | alpha | |||
| complex(kind=dp), | intent(in) | :: | x(*) | |||
| integer(kind=ilp), | intent(in) | :: | incx | |||
| complex(kind=dp), | intent(inout) | :: | ap(*) |
SPRFS improves the computed solution to a system of linear equations when the coefficient matrix is symmetric indefinite and packed, and provides error bounds and backward error estimates for the solution.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| complex(kind=sp), | intent(in) | :: | ap(*) | |||
| complex(kind=sp), | intent(in) | :: | afp(*) | |||
| integer(kind=ilp), | intent(in) | :: | ipiv(*) | |||
| complex(kind=sp), | intent(in) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| complex(kind=sp), | intent(inout) | :: | x(ldx,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldx | |||
| real(kind=sp), | intent(out) | :: | ferr(*) | |||
| real(kind=sp), | intent(out) | :: | berr(*) | |||
| complex(kind=sp), | intent(out) | :: | work(*) | |||
| real(kind=sp), | intent(out) | :: | rwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| real(kind=dp), | intent(in) | :: | ap(*) | |||
| real(kind=dp), | intent(in) | :: | afp(*) | |||
| integer(kind=ilp), | intent(in) | :: | ipiv(*) | |||
| real(kind=dp), | intent(in) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| real(kind=dp), | intent(inout) | :: | x(ldx,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldx | |||
| real(kind=dp), | intent(out) | :: | ferr(*) | |||
| real(kind=dp), | intent(out) | :: | berr(*) | |||
| real(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | iwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| real(kind=sp), | intent(in) | :: | ap(*) | |||
| real(kind=sp), | intent(in) | :: | afp(*) | |||
| integer(kind=ilp), | intent(in) | :: | ipiv(*) | |||
| real(kind=sp), | intent(in) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| real(kind=sp), | intent(inout) | :: | x(ldx,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldx | |||
| real(kind=sp), | intent(out) | :: | ferr(*) | |||
| real(kind=sp), | intent(out) | :: | berr(*) | |||
| real(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | iwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| complex(kind=dp), | intent(in) | :: | ap(*) | |||
| complex(kind=dp), | intent(in) | :: | afp(*) | |||
| integer(kind=ilp), | intent(in) | :: | ipiv(*) | |||
| complex(kind=dp), | intent(in) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| complex(kind=dp), | intent(inout) | :: | x(ldx,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldx | |||
| real(kind=dp), | intent(out) | :: | ferr(*) | |||
| real(kind=dp), | intent(out) | :: | berr(*) | |||
| complex(kind=dp), | intent(out) | :: | work(*) | |||
| real(kind=dp), | intent(out) | :: | rwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
CSPRFS improves the computed solution to a system of linear equations when the coefficient matrix is symmetric indefinite and packed, and provides error bounds and backward error estimates for the solution.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| complex(kind=sp), | intent(in) | :: | ap(*) | |||
| complex(kind=sp), | intent(in) | :: | afp(*) | |||
| integer(kind=ilp), | intent(in) | :: | ipiv(*) | |||
| complex(kind=sp), | intent(in) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| complex(kind=sp), | intent(inout) | :: | x(ldx,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldx | |||
| real(kind=sp), | intent(out) | :: | ferr(*) | |||
| real(kind=sp), | intent(out) | :: | berr(*) | |||
| complex(kind=sp), | intent(out) | :: | work(*) | |||
| real(kind=sp), | intent(out) | :: | rwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
DSPRFS improves the computed solution to a system of linear equations when the coefficient matrix is symmetric indefinite and packed, and provides error bounds and backward error estimates for the solution.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| real(kind=dp), | intent(in) | :: | ap(*) | |||
| real(kind=dp), | intent(in) | :: | afp(*) | |||
| integer(kind=ilp), | intent(in) | :: | ipiv(*) | |||
| real(kind=dp), | intent(in) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| real(kind=dp), | intent(inout) | :: | x(ldx,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldx | |||
| real(kind=dp), | intent(out) | :: | ferr(*) | |||
| real(kind=dp), | intent(out) | :: | berr(*) | |||
| real(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | iwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
SSPRFS improves the computed solution to a system of linear equations when the coefficient matrix is symmetric indefinite and packed, and provides error bounds and backward error estimates for the solution.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| real(kind=sp), | intent(in) | :: | ap(*) | |||
| real(kind=sp), | intent(in) | :: | afp(*) | |||
| integer(kind=ilp), | intent(in) | :: | ipiv(*) | |||
| real(kind=sp), | intent(in) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| real(kind=sp), | intent(inout) | :: | x(ldx,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldx | |||
| real(kind=sp), | intent(out) | :: | ferr(*) | |||
| real(kind=sp), | intent(out) | :: | berr(*) | |||
| real(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | iwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
ZSPRFS improves the computed solution to a system of linear equations when the coefficient matrix is symmetric indefinite and packed, and provides error bounds and backward error estimates for the solution.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| complex(kind=dp), | intent(in) | :: | ap(*) | |||
| complex(kind=dp), | intent(in) | :: | afp(*) | |||
| integer(kind=ilp), | intent(in) | :: | ipiv(*) | |||
| complex(kind=dp), | intent(in) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| complex(kind=dp), | intent(inout) | :: | x(ldx,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldx | |||
| real(kind=dp), | intent(out) | :: | ferr(*) | |||
| real(kind=dp), | intent(out) | :: | berr(*) | |||
| complex(kind=dp), | intent(out) | :: | work(*) | |||
| real(kind=dp), | intent(out) | :: | rwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
SPSV computes the solution to a complex system of linear equations A * X = B, where A is an N-by-N symmetric matrix stored in packed format and X and B are N-by-NRHS matrices. The diagonal pivoting method is used to factor A as A = U * D * UT, if UPLO = 'U', or A = L * D * LT, if UPLO = 'L', where U (or L) is a product of permutation and unit upper (lower) triangular matrices, D is symmetric and block diagonal with 1-by-1 and 2-by-2 diagonal blocks. The factored form of A is then used to solve the system of equations A * X = B.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| complex(kind=sp), | intent(inout) | :: | ap(*) | |||
| integer(kind=ilp), | intent(out) | :: | ipiv(*) | |||
| complex(kind=sp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| real(kind=dp), | intent(inout) | :: | ap(*) | |||
| integer(kind=ilp), | intent(out) | :: | ipiv(*) | |||
| real(kind=dp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| real(kind=sp), | intent(inout) | :: | ap(*) | |||
| integer(kind=ilp), | intent(out) | :: | ipiv(*) | |||
| real(kind=sp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| complex(kind=dp), | intent(inout) | :: | ap(*) | |||
| integer(kind=ilp), | intent(out) | :: | ipiv(*) | |||
| complex(kind=dp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| integer(kind=ilp), | intent(out) | :: | info |
CSPSV computes the solution to a complex system of linear equations A * X = B, where A is an N-by-N symmetric matrix stored in packed format and X and B are N-by-NRHS matrices. The diagonal pivoting method is used to factor A as A = U * D * UT, if UPLO = 'U', or A = L * D * LT, if UPLO = 'L', where U (or L) is a product of permutation and unit upper (lower) triangular matrices, D is symmetric and block diagonal with 1-by-1 and 2-by-2 diagonal blocks. The factored form of A is then used to solve the system of equations A * X = B.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| complex(kind=sp), | intent(inout) | :: | ap(*) | |||
| integer(kind=ilp), | intent(out) | :: | ipiv(*) | |||
| complex(kind=sp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| integer(kind=ilp), | intent(out) | :: | info |
DSPSV computes the solution to a real system of linear equations A * X = B, where A is an N-by-N symmetric matrix stored in packed format and X and B are N-by-NRHS matrices. The diagonal pivoting method is used to factor A as A = U * D * UT, if UPLO = 'U', or A = L * D * LT, if UPLO = 'L', where U (or L) is a product of permutation and unit upper (lower) triangular matrices, D is symmetric and block diagonal with 1-by-1 and 2-by-2 diagonal blocks. The factored form of A is then used to solve the system of equations A * X = B.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| real(kind=dp), | intent(inout) | :: | ap(*) | |||
| integer(kind=ilp), | intent(out) | :: | ipiv(*) | |||
| real(kind=dp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| integer(kind=ilp), | intent(out) | :: | info |
SSPSV computes the solution to a real system of linear equations A * X = B, where A is an N-by-N symmetric matrix stored in packed format and X and B are N-by-NRHS matrices. The diagonal pivoting method is used to factor A as A = U * D * UT, if UPLO = 'U', or A = L * D * LT, if UPLO = 'L', where U (or L) is a product of permutation and unit upper (lower) triangular matrices, D is symmetric and block diagonal with 1-by-1 and 2-by-2 diagonal blocks. The factored form of A is then used to solve the system of equations A * X = B.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| real(kind=sp), | intent(inout) | :: | ap(*) | |||
| integer(kind=ilp), | intent(out) | :: | ipiv(*) | |||
| real(kind=sp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| integer(kind=ilp), | intent(out) | :: | info |
ZSPSV computes the solution to a complex system of linear equations A * X = B, where A is an N-by-N symmetric matrix stored in packed format and X and B are N-by-NRHS matrices. The diagonal pivoting method is used to factor A as A = U * D * UT, if UPLO = 'U', or A = L * D * LT, if UPLO = 'L', where U (or L) is a product of permutation and unit upper (lower) triangular matrices, D is symmetric and block diagonal with 1-by-1 and 2-by-2 diagonal blocks. The factored form of A is then used to solve the system of equations A * X = B.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| complex(kind=dp), | intent(inout) | :: | ap(*) | |||
| integer(kind=ilp), | intent(out) | :: | ipiv(*) | |||
| complex(kind=dp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| integer(kind=ilp), | intent(out) | :: | info |
SPTRD reduces a real symmetric matrix A stored in packed form to symmetric tridiagonal form T by an orthogonal similarity transformation: Q**T * A * Q = T.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=dp), | intent(inout) | :: | ap(*) | |||
| real(kind=dp), | intent(out) | :: | d(*) | |||
| real(kind=dp), | intent(out) | :: | e(*) | |||
| real(kind=dp), | intent(out) | :: | tau(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=sp), | intent(inout) | :: | ap(*) | |||
| real(kind=sp), | intent(out) | :: | d(*) | |||
| real(kind=sp), | intent(out) | :: | e(*) | |||
| real(kind=sp), | intent(out) | :: | tau(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
DSPTRD reduces a real symmetric matrix A stored in packed form to symmetric tridiagonal form T by an orthogonal similarity transformation: Q**T * A * Q = T.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=dp), | intent(inout) | :: | ap(*) | |||
| real(kind=dp), | intent(out) | :: | d(*) | |||
| real(kind=dp), | intent(out) | :: | e(*) | |||
| real(kind=dp), | intent(out) | :: | tau(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
SSPTRD reduces a real symmetric matrix A stored in packed form to symmetric tridiagonal form T by an orthogonal similarity transformation: Q**T * A * Q = T.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=sp), | intent(inout) | :: | ap(*) | |||
| real(kind=sp), | intent(out) | :: | d(*) | |||
| real(kind=sp), | intent(out) | :: | e(*) | |||
| real(kind=sp), | intent(out) | :: | tau(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
SPTRF computes the factorization of a complex symmetric matrix A stored in packed format using the Bunch-Kaufman diagonal pivoting method: A = UDUT or A = LDLT where U (or L) is a product of permutation and unit upper (lower) triangular matrices, and D is symmetric and block diagonal with 1-by-1 and 2-by-2 diagonal blocks.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=sp), | intent(inout) | :: | ap(*) | |||
| integer(kind=ilp), | intent(out) | :: | ipiv(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=dp), | intent(inout) | :: | ap(*) | |||
| integer(kind=ilp), | intent(out) | :: | ipiv(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=sp), | intent(inout) | :: | ap(*) | |||
| integer(kind=ilp), | intent(out) | :: | ipiv(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=dp), | intent(inout) | :: | ap(*) | |||
| integer(kind=ilp), | intent(out) | :: | ipiv(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
CSPTRF computes the factorization of a complex symmetric matrix A stored in packed format using the Bunch-Kaufman diagonal pivoting method: A = UDUT or A = LDLT where U (or L) is a product of permutation and unit upper (lower) triangular matrices, and D is symmetric and block diagonal with 1-by-1 and 2-by-2 diagonal blocks.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=sp), | intent(inout) | :: | ap(*) | |||
| integer(kind=ilp), | intent(out) | :: | ipiv(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
DSPTRF computes the factorization of a real symmetric matrix A stored in packed format using the Bunch-Kaufman diagonal pivoting method: A = UDUT or A = LDLT where U (or L) is a product of permutation and unit upper (lower) triangular matrices, and D is symmetric and block diagonal with 1-by-1 and 2-by-2 diagonal blocks.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=dp), | intent(inout) | :: | ap(*) | |||
| integer(kind=ilp), | intent(out) | :: | ipiv(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
SSPTRF computes the factorization of a real symmetric matrix A stored in packed format using the Bunch-Kaufman diagonal pivoting method: A = UDUT or A = LDLT where U (or L) is a product of permutation and unit upper (lower) triangular matrices, and D is symmetric and block diagonal with 1-by-1 and 2-by-2 diagonal blocks.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=sp), | intent(inout) | :: | ap(*) | |||
| integer(kind=ilp), | intent(out) | :: | ipiv(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
ZSPTRF computes the factorization of a complex symmetric matrix A stored in packed format using the Bunch-Kaufman diagonal pivoting method: A = UDUT or A = LDLT where U (or L) is a product of permutation and unit upper (lower) triangular matrices, and D is symmetric and block diagonal with 1-by-1 and 2-by-2 diagonal blocks.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=dp), | intent(inout) | :: | ap(*) | |||
| integer(kind=ilp), | intent(out) | :: | ipiv(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
SPTRI computes the inverse of a complex symmetric indefinite matrix A in packed storage using the factorization A = UDUT or A = LDLT computed by CSPTRF.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=sp), | intent(inout) | :: | ap(*) | |||
| integer(kind=ilp), | intent(in) | :: | ipiv(*) | |||
| complex(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=dp), | intent(inout) | :: | ap(*) | |||
| integer(kind=ilp), | intent(in) | :: | ipiv(*) | |||
| real(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=sp), | intent(inout) | :: | ap(*) | |||
| integer(kind=ilp), | intent(in) | :: | ipiv(*) | |||
| real(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=dp), | intent(inout) | :: | ap(*) | |||
| integer(kind=ilp), | intent(in) | :: | ipiv(*) | |||
| complex(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
CSPTRI computes the inverse of a complex symmetric indefinite matrix A in packed storage using the factorization A = UDUT or A = LDLT computed by CSPTRF.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=sp), | intent(inout) | :: | ap(*) | |||
| integer(kind=ilp), | intent(in) | :: | ipiv(*) | |||
| complex(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
DSPTRI computes the inverse of a real symmetric indefinite matrix A in packed storage using the factorization A = UDUT or A = LDLT computed by DSPTRF.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=dp), | intent(inout) | :: | ap(*) | |||
| integer(kind=ilp), | intent(in) | :: | ipiv(*) | |||
| real(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
SSPTRI computes the inverse of a real symmetric indefinite matrix A in packed storage using the factorization A = UDUT or A = LDLT computed by SSPTRF.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=sp), | intent(inout) | :: | ap(*) | |||
| integer(kind=ilp), | intent(in) | :: | ipiv(*) | |||
| real(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
ZSPTRI computes the inverse of a complex symmetric indefinite matrix A in packed storage using the factorization A = UDUT or A = LDLT computed by ZSPTRF.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=dp), | intent(inout) | :: | ap(*) | |||
| integer(kind=ilp), | intent(in) | :: | ipiv(*) | |||
| complex(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
SPTRS solves a system of linear equations AX = B with a complex symmetric matrix A stored in packed format using the factorization A = UDUT or A = LDL*T computed by CSPTRF.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| complex(kind=sp), | intent(in) | :: | ap(*) | |||
| integer(kind=ilp), | intent(in) | :: | ipiv(*) | |||
| complex(kind=sp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| real(kind=dp), | intent(in) | :: | ap(*) | |||
| integer(kind=ilp), | intent(in) | :: | ipiv(*) | |||
| real(kind=dp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| real(kind=sp), | intent(in) | :: | ap(*) | |||
| integer(kind=ilp), | intent(in) | :: | ipiv(*) | |||
| real(kind=sp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| complex(kind=dp), | intent(in) | :: | ap(*) | |||
| integer(kind=ilp), | intent(in) | :: | ipiv(*) | |||
| complex(kind=dp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| integer(kind=ilp), | intent(out) | :: | info |
CSPTRS solves a system of linear equations AX = B with a complex symmetric matrix A stored in packed format using the factorization A = UDUT or A = LDL*T computed by CSPTRF.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| complex(kind=sp), | intent(in) | :: | ap(*) | |||
| integer(kind=ilp), | intent(in) | :: | ipiv(*) | |||
| complex(kind=sp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| integer(kind=ilp), | intent(out) | :: | info |
DSPTRS solves a system of linear equations AX = B with a real symmetric matrix A stored in packed format using the factorization A = UDUT or A = LDL*T computed by DSPTRF.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| real(kind=dp), | intent(in) | :: | ap(*) | |||
| integer(kind=ilp), | intent(in) | :: | ipiv(*) | |||
| real(kind=dp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| integer(kind=ilp), | intent(out) | :: | info |
SSPTRS solves a system of linear equations AX = B with a real symmetric matrix A stored in packed format using the factorization A = UDUT or A = LDL*T computed by SSPTRF.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| real(kind=sp), | intent(in) | :: | ap(*) | |||
| integer(kind=ilp), | intent(in) | :: | ipiv(*) | |||
| real(kind=sp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| integer(kind=ilp), | intent(out) | :: | info |
ZSPTRS solves a system of linear equations AX = B with a complex symmetric matrix A stored in packed format using the factorization A = UDUT or A = LDL*T computed by ZSPTRF.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| complex(kind=dp), | intent(in) | :: | ap(*) | |||
| integer(kind=ilp), | intent(in) | :: | ipiv(*) | |||
| complex(kind=dp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| integer(kind=ilp), | intent(out) | :: | info |
STEBZ computes the eigenvalues of a symmetric tridiagonal matrix T. The user may ask for all eigenvalues, all eigenvalues in the half-open interval (VL, VU], or the IL-th through IU-th eigenvalues. To avoid overflow, the matrix must be scaled so that its largest element is no greater than overflow(1/2) * underflow(1/4) in absolute value, and for greatest accuracy, it should not be much smaller than that. See W. Kahan "Accurate Eigenvalues of a Symmetric Tridiagonal Matrix", Report CS41, Computer Science Dept., Stanford University, July 21, 1966.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | range | |||
| character, | intent(in) | :: | order | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=dp), | intent(in) | :: | vl | |||
| real(kind=dp), | intent(in) | :: | vu | |||
| integer(kind=ilp), | intent(in) | :: | il | |||
| integer(kind=ilp), | intent(in) | :: | iu | |||
| real(kind=dp), | intent(in) | :: | abstol | |||
| real(kind=dp), | intent(in) | :: | d(*) | |||
| real(kind=dp), | intent(in) | :: | e(*) | |||
| integer(kind=ilp), | intent(out) | :: | m | |||
| integer(kind=ilp), | intent(out) | :: | nsplit | |||
| real(kind=dp), | intent(out) | :: | w(*) | |||
| integer(kind=ilp), | intent(out) | :: | iblock(*) | |||
| integer(kind=ilp), | intent(out) | :: | isplit(*) | |||
| real(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | iwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | range | |||
| character, | intent(in) | :: | order | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=sp), | intent(in) | :: | vl | |||
| real(kind=sp), | intent(in) | :: | vu | |||
| integer(kind=ilp), | intent(in) | :: | il | |||
| integer(kind=ilp), | intent(in) | :: | iu | |||
| real(kind=sp), | intent(in) | :: | abstol | |||
| real(kind=sp), | intent(in) | :: | d(*) | |||
| real(kind=sp), | intent(in) | :: | e(*) | |||
| integer(kind=ilp), | intent(out) | :: | m | |||
| integer(kind=ilp), | intent(out) | :: | nsplit | |||
| real(kind=sp), | intent(out) | :: | w(*) | |||
| integer(kind=ilp), | intent(out) | :: | iblock(*) | |||
| integer(kind=ilp), | intent(out) | :: | isplit(*) | |||
| real(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | iwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
DSTEBZ computes the eigenvalues of a symmetric tridiagonal matrix T. The user may ask for all eigenvalues, all eigenvalues in the half-open interval (VL, VU], or the IL-th through IU-th eigenvalues. To avoid overflow, the matrix must be scaled so that its largest element is no greater than overflow(1/2) * underflow(1/4) in absolute value, and for greatest accuracy, it should not be much smaller than that. See W. Kahan "Accurate Eigenvalues of a Symmetric Tridiagonal Matrix", Report CS41, Computer Science Dept., Stanford University, July 21, 1966.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | range | |||
| character, | intent(in) | :: | order | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=dp), | intent(in) | :: | vl | |||
| real(kind=dp), | intent(in) | :: | vu | |||
| integer(kind=ilp), | intent(in) | :: | il | |||
| integer(kind=ilp), | intent(in) | :: | iu | |||
| real(kind=dp), | intent(in) | :: | abstol | |||
| real(kind=dp), | intent(in) | :: | d(*) | |||
| real(kind=dp), | intent(in) | :: | e(*) | |||
| integer(kind=ilp), | intent(out) | :: | m | |||
| integer(kind=ilp), | intent(out) | :: | nsplit | |||
| real(kind=dp), | intent(out) | :: | w(*) | |||
| integer(kind=ilp), | intent(out) | :: | iblock(*) | |||
| integer(kind=ilp), | intent(out) | :: | isplit(*) | |||
| real(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | iwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
SSTEBZ computes the eigenvalues of a symmetric tridiagonal matrix T. The user may ask for all eigenvalues, all eigenvalues in the half-open interval (VL, VU], or the IL-th through IU-th eigenvalues. To avoid overflow, the matrix must be scaled so that its largest element is no greater than overflow(1/2) * underflow(1/4) in absolute value, and for greatest accuracy, it should not be much smaller than that. See W. Kahan "Accurate Eigenvalues of a Symmetric Tridiagonal Matrix", Report CS41, Computer Science Dept., Stanford University, July 21, 1966.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | range | |||
| character, | intent(in) | :: | order | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=sp), | intent(in) | :: | vl | |||
| real(kind=sp), | intent(in) | :: | vu | |||
| integer(kind=ilp), | intent(in) | :: | il | |||
| integer(kind=ilp), | intent(in) | :: | iu | |||
| real(kind=sp), | intent(in) | :: | abstol | |||
| real(kind=sp), | intent(in) | :: | d(*) | |||
| real(kind=sp), | intent(in) | :: | e(*) | |||
| integer(kind=ilp), | intent(out) | :: | m | |||
| integer(kind=ilp), | intent(out) | :: | nsplit | |||
| real(kind=sp), | intent(out) | :: | w(*) | |||
| integer(kind=ilp), | intent(out) | :: | iblock(*) | |||
| integer(kind=ilp), | intent(out) | :: | isplit(*) | |||
| real(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | iwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
STEDC computes all eigenvalues and, optionally, eigenvectors of a symmetric tridiagonal matrix using the divide and conquer method. The eigenvectors of a full or band complex Hermitian matrix can also be found if CHETRD or CHPTRD or CHBTRD has been used to reduce this matrix to tridiagonal form. This code makes very mild assumptions about floating point arithmetic. It will work on machines with a guard digit in add/subtract, or on those binary machines without guard digits which subtract like the Cray X-MP, Cray Y-MP, Cray C-90, or Cray-2. It could conceivably fail on hexadecimal or decimal machines without guard digits, but we know of none. See SLAED3 for details.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | compz | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=sp), | intent(inout) | :: | d(*) | |||
| real(kind=sp), | intent(inout) | :: | e(*) | |||
| complex(kind=sp), | intent(inout) | :: | z(ldz,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldz | |||
| complex(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| real(kind=sp), | intent(out) | :: | rwork(*) | |||
| integer(kind=ilp), | intent(in) | :: | lrwork | |||
| integer(kind=ilp), | intent(out) | :: | iwork(*) | |||
| integer(kind=ilp), | intent(in) | :: | liwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | compz | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=dp), | intent(inout) | :: | d(*) | |||
| real(kind=dp), | intent(inout) | :: | e(*) | |||
| real(kind=dp), | intent(inout) | :: | z(ldz,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldz | |||
| real(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | iwork(*) | |||
| integer(kind=ilp), | intent(in) | :: | liwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | compz | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=sp), | intent(inout) | :: | d(*) | |||
| real(kind=sp), | intent(inout) | :: | e(*) | |||
| real(kind=sp), | intent(inout) | :: | z(ldz,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldz | |||
| real(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | iwork(*) | |||
| integer(kind=ilp), | intent(in) | :: | liwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | compz | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=dp), | intent(inout) | :: | d(*) | |||
| real(kind=dp), | intent(inout) | :: | e(*) | |||
| complex(kind=dp), | intent(inout) | :: | z(ldz,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldz | |||
| complex(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| real(kind=dp), | intent(out) | :: | rwork(*) | |||
| integer(kind=ilp), | intent(in) | :: | lrwork | |||
| integer(kind=ilp), | intent(out) | :: | iwork(*) | |||
| integer(kind=ilp), | intent(in) | :: | liwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
CSTEDC computes all eigenvalues and, optionally, eigenvectors of a symmetric tridiagonal matrix using the divide and conquer method. The eigenvectors of a full or band complex Hermitian matrix can also be found if CHETRD or CHPTRD or CHBTRD has been used to reduce this matrix to tridiagonal form. This code makes very mild assumptions about floating point arithmetic. It will work on machines with a guard digit in add/subtract, or on those binary machines without guard digits which subtract like the Cray X-MP, Cray Y-MP, Cray C-90, or Cray-2. It could conceivably fail on hexadecimal or decimal machines without guard digits, but we know of none. See SLAED3 for details.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | compz | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=sp), | intent(inout) | :: | d(*) | |||
| real(kind=sp), | intent(inout) | :: | e(*) | |||
| complex(kind=sp), | intent(inout) | :: | z(ldz,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldz | |||
| complex(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| real(kind=sp), | intent(out) | :: | rwork(*) | |||
| integer(kind=ilp), | intent(in) | :: | lrwork | |||
| integer(kind=ilp), | intent(out) | :: | iwork(*) | |||
| integer(kind=ilp), | intent(in) | :: | liwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
DSTEDC computes all eigenvalues and, optionally, eigenvectors of a symmetric tridiagonal matrix using the divide and conquer method. The eigenvectors of a full or band real symmetric matrix can also be found if DSYTRD or DSPTRD or DSBTRD has been used to reduce this matrix to tridiagonal form. This code makes very mild assumptions about floating point arithmetic. It will work on machines with a guard digit in add/subtract, or on those binary machines without guard digits which subtract like the Cray X-MP, Cray Y-MP, Cray C-90, or Cray-2. It could conceivably fail on hexadecimal or decimal machines without guard digits, but we know of none. See DLAED3 for details.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | compz | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=dp), | intent(inout) | :: | d(*) | |||
| real(kind=dp), | intent(inout) | :: | e(*) | |||
| real(kind=dp), | intent(inout) | :: | z(ldz,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldz | |||
| real(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | iwork(*) | |||
| integer(kind=ilp), | intent(in) | :: | liwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
SSTEDC computes all eigenvalues and, optionally, eigenvectors of a symmetric tridiagonal matrix using the divide and conquer method. The eigenvectors of a full or band real symmetric matrix can also be found if SSYTRD or SSPTRD or SSBTRD has been used to reduce this matrix to tridiagonal form. This code makes very mild assumptions about floating point arithmetic. It will work on machines with a guard digit in add/subtract, or on those binary machines without guard digits which subtract like the Cray X-MP, Cray Y-MP, Cray C-90, or Cray-2. It could conceivably fail on hexadecimal or decimal machines without guard digits, but we know of none. See SLAED3 for details.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | compz | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=sp), | intent(inout) | :: | d(*) | |||
| real(kind=sp), | intent(inout) | :: | e(*) | |||
| real(kind=sp), | intent(inout) | :: | z(ldz,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldz | |||
| real(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | iwork(*) | |||
| integer(kind=ilp), | intent(in) | :: | liwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
ZSTEDC computes all eigenvalues and, optionally, eigenvectors of a symmetric tridiagonal matrix using the divide and conquer method. The eigenvectors of a full or band complex Hermitian matrix can also be found if ZHETRD or ZHPTRD or ZHBTRD has been used to reduce this matrix to tridiagonal form. This code makes very mild assumptions about floating point arithmetic. It will work on machines with a guard digit in add/subtract, or on those binary machines without guard digits which subtract like the Cray X-MP, Cray Y-MP, Cray C-90, or Cray-2. It could conceivably fail on hexadecimal or decimal machines without guard digits, but we know of none. See DLAED3 for details.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | compz | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=dp), | intent(inout) | :: | d(*) | |||
| real(kind=dp), | intent(inout) | :: | e(*) | |||
| complex(kind=dp), | intent(inout) | :: | z(ldz,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldz | |||
| complex(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| real(kind=dp), | intent(out) | :: | rwork(*) | |||
| integer(kind=ilp), | intent(in) | :: | lrwork | |||
| integer(kind=ilp), | intent(out) | :: | iwork(*) | |||
| integer(kind=ilp), | intent(in) | :: | liwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
STEGR computes selected eigenvalues and, optionally, eigenvectors of a real symmetric tridiagonal matrix T. Any such unreduced matrix has a well defined set of pairwise different real eigenvalues, the corresponding real eigenvectors are pairwise orthogonal. The spectrum may be computed either completely or partially by specifying either an interval (VL,VU] or a range of indices IL:IU for the desired eigenvalues. STEGR is a compatibility wrapper around the improved CSTEMR routine. See SSTEMR for further details. One important change is that the ABSTOL parameter no longer provides any benefit and hence is no longer used. Note : STEGR and CSTEMR work only on machines which follow IEEE-754 floating-point standard in their handling of infinities and NaNs. Normal execution may create these exceptiona values and hence may abort due to a floating point exception in environments which do not conform to the IEEE-754 standard.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | jobz | |||
| character, | intent(in) | :: | range | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=sp), | intent(inout) | :: | d(*) | |||
| real(kind=sp), | intent(inout) | :: | e(*) | |||
| real(kind=sp), | intent(in) | :: | vl | |||
| real(kind=sp), | intent(in) | :: | vu | |||
| integer(kind=ilp), | intent(in) | :: | il | |||
| integer(kind=ilp), | intent(in) | :: | iu | |||
| real(kind=sp), | intent(in) | :: | abstol | |||
| integer(kind=ilp), | intent(out) | :: | m | |||
| real(kind=sp), | intent(out) | :: | w(*) | |||
| complex(kind=sp), | intent(out) | :: | z(ldz,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldz | |||
| integer(kind=ilp), | intent(out) | :: | isuppz(*) | |||
| real(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | iwork(*) | |||
| integer(kind=ilp), | intent(in) | :: | liwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | jobz | |||
| character, | intent(in) | :: | range | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=dp), | intent(inout) | :: | d(*) | |||
| real(kind=dp), | intent(inout) | :: | e(*) | |||
| real(kind=dp), | intent(in) | :: | vl | |||
| real(kind=dp), | intent(in) | :: | vu | |||
| integer(kind=ilp), | intent(in) | :: | il | |||
| integer(kind=ilp), | intent(in) | :: | iu | |||
| real(kind=dp), | intent(in) | :: | abstol | |||
| integer(kind=ilp), | intent(out) | :: | m | |||
| real(kind=dp), | intent(out) | :: | w(*) | |||
| real(kind=dp), | intent(out) | :: | z(ldz,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldz | |||
| integer(kind=ilp), | intent(out) | :: | isuppz(*) | |||
| real(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | iwork(*) | |||
| integer(kind=ilp), | intent(in) | :: | liwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | jobz | |||
| character, | intent(in) | :: | range | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=sp), | intent(inout) | :: | d(*) | |||
| real(kind=sp), | intent(inout) | :: | e(*) | |||
| real(kind=sp), | intent(in) | :: | vl | |||
| real(kind=sp), | intent(in) | :: | vu | |||
| integer(kind=ilp), | intent(in) | :: | il | |||
| integer(kind=ilp), | intent(in) | :: | iu | |||
| real(kind=sp), | intent(in) | :: | abstol | |||
| integer(kind=ilp), | intent(out) | :: | m | |||
| real(kind=sp), | intent(out) | :: | w(*) | |||
| real(kind=sp), | intent(out) | :: | z(ldz,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldz | |||
| integer(kind=ilp), | intent(out) | :: | isuppz(*) | |||
| real(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | iwork(*) | |||
| integer(kind=ilp), | intent(in) | :: | liwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | jobz | |||
| character, | intent(in) | :: | range | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=dp), | intent(inout) | :: | d(*) | |||
| real(kind=dp), | intent(inout) | :: | e(*) | |||
| real(kind=dp), | intent(in) | :: | vl | |||
| real(kind=dp), | intent(in) | :: | vu | |||
| integer(kind=ilp), | intent(in) | :: | il | |||
| integer(kind=ilp), | intent(in) | :: | iu | |||
| real(kind=dp), | intent(in) | :: | abstol | |||
| integer(kind=ilp), | intent(out) | :: | m | |||
| real(kind=dp), | intent(out) | :: | w(*) | |||
| complex(kind=dp), | intent(out) | :: | z(ldz,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldz | |||
| integer(kind=ilp), | intent(out) | :: | isuppz(*) | |||
| real(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | iwork(*) | |||
| integer(kind=ilp), | intent(in) | :: | liwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
CSTEGR computes selected eigenvalues and, optionally, eigenvectors of a real symmetric tridiagonal matrix T. Any such unreduced matrix has a well defined set of pairwise different real eigenvalues, the corresponding real eigenvectors are pairwise orthogonal. The spectrum may be computed either completely or partially by specifying either an interval (VL,VU] or a range of indices IL:IU for the desired eigenvalues. CSTEGR is a compatibility wrapper around the improved CSTEMR routine. See SSTEMR for further details. One important change is that the ABSTOL parameter no longer provides any benefit and hence is no longer used. Note : CSTEGR and CSTEMR work only on machines which follow IEEE-754 floating-point standard in their handling of infinities and NaNs. Normal execution may create these exceptiona values and hence may abort due to a floating point exception in environments which do not conform to the IEEE-754 standard.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | jobz | |||
| character, | intent(in) | :: | range | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=sp), | intent(inout) | :: | d(*) | |||
| real(kind=sp), | intent(inout) | :: | e(*) | |||
| real(kind=sp), | intent(in) | :: | vl | |||
| real(kind=sp), | intent(in) | :: | vu | |||
| integer(kind=ilp), | intent(in) | :: | il | |||
| integer(kind=ilp), | intent(in) | :: | iu | |||
| real(kind=sp), | intent(in) | :: | abstol | |||
| integer(kind=ilp), | intent(out) | :: | m | |||
| real(kind=sp), | intent(out) | :: | w(*) | |||
| complex(kind=sp), | intent(out) | :: | z(ldz,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldz | |||
| integer(kind=ilp), | intent(out) | :: | isuppz(*) | |||
| real(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | iwork(*) | |||
| integer(kind=ilp), | intent(in) | :: | liwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
DSTEGR computes selected eigenvalues and, optionally, eigenvectors of a real symmetric tridiagonal matrix T. Any such unreduced matrix has a well defined set of pairwise different real eigenvalues, the corresponding real eigenvectors are pairwise orthogonal. The spectrum may be computed either completely or partially by specifying either an interval (VL,VU] or a range of indices IL:IU for the desired eigenvalues. DSTEGR is a compatibility wrapper around the improved DSTEMR routine. See DSTEMR for further details. One important change is that the ABSTOL parameter no longer provides any benefit and hence is no longer used. Note : DSTEGR and DSTEMR work only on machines which follow IEEE-754 floating-point standard in their handling of infinities and NaNs. Normal execution may create these exceptiona values and hence may abort due to a floating point exception in environments which do not conform to the IEEE-754 standard.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | jobz | |||
| character, | intent(in) | :: | range | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=dp), | intent(inout) | :: | d(*) | |||
| real(kind=dp), | intent(inout) | :: | e(*) | |||
| real(kind=dp), | intent(in) | :: | vl | |||
| real(kind=dp), | intent(in) | :: | vu | |||
| integer(kind=ilp), | intent(in) | :: | il | |||
| integer(kind=ilp), | intent(in) | :: | iu | |||
| real(kind=dp), | intent(in) | :: | abstol | |||
| integer(kind=ilp), | intent(out) | :: | m | |||
| real(kind=dp), | intent(out) | :: | w(*) | |||
| real(kind=dp), | intent(out) | :: | z(ldz,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldz | |||
| integer(kind=ilp), | intent(out) | :: | isuppz(*) | |||
| real(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | iwork(*) | |||
| integer(kind=ilp), | intent(in) | :: | liwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
SSTEGR computes selected eigenvalues and, optionally, eigenvectors of a real symmetric tridiagonal matrix T. Any such unreduced matrix has a well defined set of pairwise different real eigenvalues, the corresponding real eigenvectors are pairwise orthogonal. The spectrum may be computed either completely or partially by specifying either an interval (VL,VU] or a range of indices IL:IU for the desired eigenvalues. SSTEGR is a compatibility wrapper around the improved SSTEMR routine. See SSTEMR for further details. One important change is that the ABSTOL parameter no longer provides any benefit and hence is no longer used. Note : SSTEGR and SSTEMR work only on machines which follow IEEE-754 floating-point standard in their handling of infinities and NaNs. Normal execution may create these exceptiona values and hence may abort due to a floating point exception in environments which do not conform to the IEEE-754 standard.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | jobz | |||
| character, | intent(in) | :: | range | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=sp), | intent(inout) | :: | d(*) | |||
| real(kind=sp), | intent(inout) | :: | e(*) | |||
| real(kind=sp), | intent(in) | :: | vl | |||
| real(kind=sp), | intent(in) | :: | vu | |||
| integer(kind=ilp), | intent(in) | :: | il | |||
| integer(kind=ilp), | intent(in) | :: | iu | |||
| real(kind=sp), | intent(in) | :: | abstol | |||
| integer(kind=ilp), | intent(out) | :: | m | |||
| real(kind=sp), | intent(out) | :: | w(*) | |||
| real(kind=sp), | intent(out) | :: | z(ldz,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldz | |||
| integer(kind=ilp), | intent(out) | :: | isuppz(*) | |||
| real(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | iwork(*) | |||
| integer(kind=ilp), | intent(in) | :: | liwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
ZSTEGR computes selected eigenvalues and, optionally, eigenvectors of a real symmetric tridiagonal matrix T. Any such unreduced matrix has a well defined set of pairwise different real eigenvalues, the corresponding real eigenvectors are pairwise orthogonal. The spectrum may be computed either completely or partially by specifying either an interval (VL,VU] or a range of indices IL:IU for the desired eigenvalues. ZSTEGR is a compatibility wrapper around the improved ZSTEMR routine. See ZSTEMR for further details. One important change is that the ABSTOL parameter no longer provides any benefit and hence is no longer used. Note : ZSTEGR and ZSTEMR work only on machines which follow IEEE-754 floating-point standard in their handling of infinities and NaNs. Normal execution may create these exceptiona values and hence may abort due to a floating point exception in environments which do not conform to the IEEE-754 standard.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | jobz | |||
| character, | intent(in) | :: | range | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=dp), | intent(inout) | :: | d(*) | |||
| real(kind=dp), | intent(inout) | :: | e(*) | |||
| real(kind=dp), | intent(in) | :: | vl | |||
| real(kind=dp), | intent(in) | :: | vu | |||
| integer(kind=ilp), | intent(in) | :: | il | |||
| integer(kind=ilp), | intent(in) | :: | iu | |||
| real(kind=dp), | intent(in) | :: | abstol | |||
| integer(kind=ilp), | intent(out) | :: | m | |||
| real(kind=dp), | intent(out) | :: | w(*) | |||
| complex(kind=dp), | intent(out) | :: | z(ldz,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldz | |||
| integer(kind=ilp), | intent(out) | :: | isuppz(*) | |||
| real(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | iwork(*) | |||
| integer(kind=ilp), | intent(in) | :: | liwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
STEIN computes the eigenvectors of a real symmetric tridiagonal matrix T corresponding to specified eigenvalues, using inverse iteration. The maximum number of iterations allowed for each eigenvector is specified by an internal parameter MAXITS (currently set to 5). Although the eigenvectors are real, they are stored in a complex array, which may be passed to CUNMTR or CUPMTR for back transformation to the eigenvectors of a complex Hermitian matrix which was reduced to tridiagonal form.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=sp), | intent(in) | :: | d(*) | |||
| real(kind=sp), | intent(in) | :: | e(*) | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| real(kind=sp), | intent(in) | :: | w(*) | |||
| integer(kind=ilp), | intent(in) | :: | iblock(*) | |||
| integer(kind=ilp), | intent(in) | :: | isplit(*) | |||
| complex(kind=sp), | intent(out) | :: | z(ldz,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldz | |||
| real(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | iwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | ifail(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=dp), | intent(in) | :: | d(*) | |||
| real(kind=dp), | intent(in) | :: | e(*) | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| real(kind=dp), | intent(in) | :: | w(*) | |||
| integer(kind=ilp), | intent(in) | :: | iblock(*) | |||
| integer(kind=ilp), | intent(in) | :: | isplit(*) | |||
| real(kind=dp), | intent(out) | :: | z(ldz,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldz | |||
| real(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | iwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | ifail(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=sp), | intent(in) | :: | d(*) | |||
| real(kind=sp), | intent(in) | :: | e(*) | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| real(kind=sp), | intent(in) | :: | w(*) | |||
| integer(kind=ilp), | intent(in) | :: | iblock(*) | |||
| integer(kind=ilp), | intent(in) | :: | isplit(*) | |||
| real(kind=sp), | intent(out) | :: | z(ldz,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldz | |||
| real(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | iwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | ifail(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=dp), | intent(in) | :: | d(*) | |||
| real(kind=dp), | intent(in) | :: | e(*) | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| real(kind=dp), | intent(in) | :: | w(*) | |||
| integer(kind=ilp), | intent(in) | :: | iblock(*) | |||
| integer(kind=ilp), | intent(in) | :: | isplit(*) | |||
| complex(kind=dp), | intent(out) | :: | z(ldz,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldz | |||
| real(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | iwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | ifail(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
CSTEIN computes the eigenvectors of a real symmetric tridiagonal matrix T corresponding to specified eigenvalues, using inverse iteration. The maximum number of iterations allowed for each eigenvector is specified by an internal parameter MAXITS (currently set to 5). Although the eigenvectors are real, they are stored in a complex array, which may be passed to CUNMTR or CUPMTR for back transformation to the eigenvectors of a complex Hermitian matrix which was reduced to tridiagonal form.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=sp), | intent(in) | :: | d(*) | |||
| real(kind=sp), | intent(in) | :: | e(*) | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| real(kind=sp), | intent(in) | :: | w(*) | |||
| integer(kind=ilp), | intent(in) | :: | iblock(*) | |||
| integer(kind=ilp), | intent(in) | :: | isplit(*) | |||
| complex(kind=sp), | intent(out) | :: | z(ldz,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldz | |||
| real(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | iwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | ifail(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
DSTEIN computes the eigenvectors of a real symmetric tridiagonal matrix T corresponding to specified eigenvalues, using inverse iteration. The maximum number of iterations allowed for each eigenvector is specified by an internal parameter MAXITS (currently set to 5).
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=dp), | intent(in) | :: | d(*) | |||
| real(kind=dp), | intent(in) | :: | e(*) | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| real(kind=dp), | intent(in) | :: | w(*) | |||
| integer(kind=ilp), | intent(in) | :: | iblock(*) | |||
| integer(kind=ilp), | intent(in) | :: | isplit(*) | |||
| real(kind=dp), | intent(out) | :: | z(ldz,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldz | |||
| real(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | iwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | ifail(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
SSTEIN computes the eigenvectors of a real symmetric tridiagonal matrix T corresponding to specified eigenvalues, using inverse iteration. The maximum number of iterations allowed for each eigenvector is specified by an internal parameter MAXITS (currently set to 5).
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=sp), | intent(in) | :: | d(*) | |||
| real(kind=sp), | intent(in) | :: | e(*) | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| real(kind=sp), | intent(in) | :: | w(*) | |||
| integer(kind=ilp), | intent(in) | :: | iblock(*) | |||
| integer(kind=ilp), | intent(in) | :: | isplit(*) | |||
| real(kind=sp), | intent(out) | :: | z(ldz,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldz | |||
| real(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | iwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | ifail(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
ZSTEIN computes the eigenvectors of a real symmetric tridiagonal matrix T corresponding to specified eigenvalues, using inverse iteration. The maximum number of iterations allowed for each eigenvector is specified by an internal parameter MAXITS (currently set to 5). Although the eigenvectors are real, they are stored in a complex array, which may be passed to ZUNMTR or ZUPMTR for back transformation to the eigenvectors of a complex Hermitian matrix which was reduced to tridiagonal form.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=dp), | intent(in) | :: | d(*) | |||
| real(kind=dp), | intent(in) | :: | e(*) | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| real(kind=dp), | intent(in) | :: | w(*) | |||
| integer(kind=ilp), | intent(in) | :: | iblock(*) | |||
| integer(kind=ilp), | intent(in) | :: | isplit(*) | |||
| complex(kind=dp), | intent(out) | :: | z(ldz,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldz | |||
| real(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | iwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | ifail(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
STEMR computes selected eigenvalues and, optionally, eigenvectors of a real symmetric tridiagonal matrix T. Any such unreduced matrix has a well defined set of pairwise different real eigenvalues, the corresponding real eigenvectors are pairwise orthogonal. The spectrum may be computed either completely or partially by specifying either an interval (VL,VU] or a range of indices IL:IU for the desired eigenvalues. Depending on the number of desired eigenvalues, these are computed either by bisection or the dqds algorithm. Numerically orthogonal eigenvectors are computed by the use of various suitable L D L^T factorizations near clusters of close eigenvalues (referred to as RRRs, Relatively Robust Representations). An informal sketch of the algorithm follows. For each unreduced block (submatrix) of T, (a) Compute T - sigma I = L D L^T, so that L and D define all the wanted eigenvalues to high relative accuracy. This means that small relative changes in the entries of D and L cause only small relative changes in the eigenvalues and eigenvectors. The standard (unfactored) representation of the tridiagonal matrix T does not have this property in general. (b) Compute the eigenvalues to suitable accuracy. If the eigenvectors are desired, the algorithm attains full accuracy of the computed eigenvalues only right before the corresponding vectors have to be computed, see steps c) and d). (c) For each cluster of close eigenvalues, select a new shift close to the cluster, find a new factorization, and refine the shifted eigenvalues to suitable accuracy. (d) For each eigenvalue with a large enough relative separation compute the corresponding eigenvector by forming a rank revealing twisted factorization. Go back to (c) for any clusters that remain. For more details, see: - Inderjit S. Dhillon and Beresford N. Parlett: "Multiple representations to compute orthogonal eigenvectors of symmetric tridiagonal matrices," Linear Algebra and its Applications, 387(1), pp. 1-28, August 2004. - Inderjit Dhillon and Beresford Parlett: "Orthogonal Eigenvectors and Relative Gaps," SIAM Journal on Matrix Analysis and Applications, Vol. 25, 2004. Also LAPACK Working Note 154. - Inderjit Dhillon: "A new O(n^2) algorithm for the symmetric tridiagonal eigenvalue/eigenvector problem", Computer Science Division Technical Report No. UCB/CSD-97-971, UC Berkeley, May 1997. Further Details 1.STEMR works only on machines which follow IEEE-754 floating-point standard in their handling of infinities and NaNs. This permits the use of efficient inner loops avoiding a check for zero divisors. 2. LAPACK routines can be used to reduce a complex Hermitean matrix to real symmetric tridiagonal form. (Any complex Hermitean tridiagonal matrix has real values on its diagonal and potentially complex numbers on its off-diagonals. By applying a similarity transform with an appropriate diagonal matrix diag(1,e^{i \phy_1}, ... , e^{i \phy_{n-1}}), the complex Hermitean matrix can be transformed into a real symmetric matrix and complex arithmetic can be entirely avoided.) While the eigenvectors of the real symmetric tridiagonal matrix are real, the eigenvectors of original complex Hermitean matrix have complex entries in general. Since LAPACK drivers overwrite the matrix data with the eigenvectors, STEMR accepts complex workspace to facilitate interoperability with CUNMTR or CUPMTR.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | jobz | |||
| character, | intent(in) | :: | range | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=sp), | intent(inout) | :: | d(*) | |||
| real(kind=sp), | intent(inout) | :: | e(*) | |||
| real(kind=sp), | intent(in) | :: | vl | |||
| real(kind=sp), | intent(in) | :: | vu | |||
| integer(kind=ilp), | intent(in) | :: | il | |||
| integer(kind=ilp), | intent(in) | :: | iu | |||
| integer(kind=ilp), | intent(out) | :: | m | |||
| real(kind=sp), | intent(out) | :: | w(*) | |||
| complex(kind=sp), | intent(out) | :: | z(ldz,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldz | |||
| integer(kind=ilp), | intent(in) | :: | nzc | |||
| integer(kind=ilp), | intent(out) | :: | isuppz(*) | |||
| logical(kind=lk), | intent(inout) | :: | tryrac | |||
| real(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | iwork(*) | |||
| integer(kind=ilp), | intent(in) | :: | liwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | jobz | |||
| character, | intent(in) | :: | range | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=dp), | intent(inout) | :: | d(*) | |||
| real(kind=dp), | intent(inout) | :: | e(*) | |||
| real(kind=dp), | intent(in) | :: | vl | |||
| real(kind=dp), | intent(in) | :: | vu | |||
| integer(kind=ilp), | intent(in) | :: | il | |||
| integer(kind=ilp), | intent(in) | :: | iu | |||
| integer(kind=ilp), | intent(out) | :: | m | |||
| real(kind=dp), | intent(out) | :: | w(*) | |||
| real(kind=dp), | intent(out) | :: | z(ldz,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldz | |||
| integer(kind=ilp), | intent(in) | :: | nzc | |||
| integer(kind=ilp), | intent(out) | :: | isuppz(*) | |||
| logical(kind=lk), | intent(inout) | :: | tryrac | |||
| real(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | iwork(*) | |||
| integer(kind=ilp), | intent(in) | :: | liwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | jobz | |||
| character, | intent(in) | :: | range | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=sp), | intent(inout) | :: | d(*) | |||
| real(kind=sp), | intent(inout) | :: | e(*) | |||
| real(kind=sp), | intent(in) | :: | vl | |||
| real(kind=sp), | intent(in) | :: | vu | |||
| integer(kind=ilp), | intent(in) | :: | il | |||
| integer(kind=ilp), | intent(in) | :: | iu | |||
| integer(kind=ilp), | intent(out) | :: | m | |||
| real(kind=sp), | intent(out) | :: | w(*) | |||
| real(kind=sp), | intent(out) | :: | z(ldz,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldz | |||
| integer(kind=ilp), | intent(in) | :: | nzc | |||
| integer(kind=ilp), | intent(out) | :: | isuppz(*) | |||
| logical(kind=lk), | intent(inout) | :: | tryrac | |||
| real(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | iwork(*) | |||
| integer(kind=ilp), | intent(in) | :: | liwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | jobz | |||
| character, | intent(in) | :: | range | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=dp), | intent(inout) | :: | d(*) | |||
| real(kind=dp), | intent(inout) | :: | e(*) | |||
| real(kind=dp), | intent(in) | :: | vl | |||
| real(kind=dp), | intent(in) | :: | vu | |||
| integer(kind=ilp), | intent(in) | :: | il | |||
| integer(kind=ilp), | intent(in) | :: | iu | |||
| integer(kind=ilp), | intent(out) | :: | m | |||
| real(kind=dp), | intent(out) | :: | w(*) | |||
| complex(kind=dp), | intent(out) | :: | z(ldz,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldz | |||
| integer(kind=ilp), | intent(in) | :: | nzc | |||
| integer(kind=ilp), | intent(out) | :: | isuppz(*) | |||
| logical(kind=lk), | intent(inout) | :: | tryrac | |||
| real(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | iwork(*) | |||
| integer(kind=ilp), | intent(in) | :: | liwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
CSTEMR computes selected eigenvalues and, optionally, eigenvectors of a real symmetric tridiagonal matrix T. Any such unreduced matrix has a well defined set of pairwise different real eigenvalues, the corresponding real eigenvectors are pairwise orthogonal. The spectrum may be computed either completely or partially by specifying either an interval (VL,VU] or a range of indices IL:IU for the desired eigenvalues. Depending on the number of desired eigenvalues, these are computed either by bisection or the dqds algorithm. Numerically orthogonal eigenvectors are computed by the use of various suitable L D L^T factorizations near clusters of close eigenvalues (referred to as RRRs, Relatively Robust Representations). An informal sketch of the algorithm follows. For each unreduced block (submatrix) of T, (a) Compute T - sigma I = L D L^T, so that L and D define all the wanted eigenvalues to high relative accuracy. This means that small relative changes in the entries of D and L cause only small relative changes in the eigenvalues and eigenvectors. The standard (unfactored) representation of the tridiagonal matrix T does not have this property in general. (b) Compute the eigenvalues to suitable accuracy. If the eigenvectors are desired, the algorithm attains full accuracy of the computed eigenvalues only right before the corresponding vectors have to be computed, see steps c) and d). (c) For each cluster of close eigenvalues, select a new shift close to the cluster, find a new factorization, and refine the shifted eigenvalues to suitable accuracy. (d) For each eigenvalue with a large enough relative separation compute the corresponding eigenvector by forming a rank revealing twisted factorization. Go back to (c) for any clusters that remain. For more details, see: - Inderjit S. Dhillon and Beresford N. Parlett: "Multiple representations to compute orthogonal eigenvectors of symmetric tridiagonal matrices," Linear Algebra and its Applications, 387(1), pp. 1-28, August 2004. - Inderjit Dhillon and Beresford Parlett: "Orthogonal Eigenvectors and Relative Gaps," SIAM Journal on Matrix Analysis and Applications, Vol. 25, 2004. Also LAPACK Working Note 154. - Inderjit Dhillon: "A new O(n^2) algorithm for the symmetric tridiagonal eigenvalue/eigenvector problem", Computer Science Division Technical Report No. UCB/CSD-97-971, UC Berkeley, May 1997. Further Details 1.CSTEMR works only on machines which follow IEEE-754 floating-point standard in their handling of infinities and NaNs. This permits the use of efficient inner loops avoiding a check for zero divisors. 2. LAPACK routines can be used to reduce a complex Hermitean matrix to real symmetric tridiagonal form. (Any complex Hermitean tridiagonal matrix has real values on its diagonal and potentially complex numbers on its off-diagonals. By applying a similarity transform with an appropriate diagonal matrix diag(1,e^{i \phy_1}, ... , e^{i \phy_{n-1}}), the complex Hermitean matrix can be transformed into a real symmetric matrix and complex arithmetic can be entirely avoided.) While the eigenvectors of the real symmetric tridiagonal matrix are real, the eigenvectors of original complex Hermitean matrix have complex entries in general. Since LAPACK drivers overwrite the matrix data with the eigenvectors, CSTEMR accepts complex workspace to facilitate interoperability with CUNMTR or CUPMTR.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | jobz | |||
| character, | intent(in) | :: | range | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=sp), | intent(inout) | :: | d(*) | |||
| real(kind=sp), | intent(inout) | :: | e(*) | |||
| real(kind=sp), | intent(in) | :: | vl | |||
| real(kind=sp), | intent(in) | :: | vu | |||
| integer(kind=ilp), | intent(in) | :: | il | |||
| integer(kind=ilp), | intent(in) | :: | iu | |||
| integer(kind=ilp), | intent(out) | :: | m | |||
| real(kind=sp), | intent(out) | :: | w(*) | |||
| complex(kind=sp), | intent(out) | :: | z(ldz,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldz | |||
| integer(kind=ilp), | intent(in) | :: | nzc | |||
| integer(kind=ilp), | intent(out) | :: | isuppz(*) | |||
| logical(kind=lk), | intent(inout) | :: | tryrac | |||
| real(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | iwork(*) | |||
| integer(kind=ilp), | intent(in) | :: | liwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
DSTEMR computes selected eigenvalues and, optionally, eigenvectors of a real symmetric tridiagonal matrix T. Any such unreduced matrix has a well defined set of pairwise different real eigenvalues, the corresponding real eigenvectors are pairwise orthogonal. The spectrum may be computed either completely or partially by specifying either an interval (VL,VU] or a range of indices IL:IU for the desired eigenvalues. Depending on the number of desired eigenvalues, these are computed either by bisection or the dqds algorithm. Numerically orthogonal eigenvectors are computed by the use of various suitable L D L^T factorizations near clusters of close eigenvalues (referred to as RRRs, Relatively Robust Representations). An informal sketch of the algorithm follows. For each unreduced block (submatrix) of T, (a) Compute T - sigma I = L D L^T, so that L and D define all the wanted eigenvalues to high relative accuracy. This means that small relative changes in the entries of D and L cause only small relative changes in the eigenvalues and eigenvectors. The standard (unfactored) representation of the tridiagonal matrix T does not have this property in general. (b) Compute the eigenvalues to suitable accuracy. If the eigenvectors are desired, the algorithm attains full accuracy of the computed eigenvalues only right before the corresponding vectors have to be computed, see steps c) and d). (c) For each cluster of close eigenvalues, select a new shift close to the cluster, find a new factorization, and refine the shifted eigenvalues to suitable accuracy. (d) For each eigenvalue with a large enough relative separation compute the corresponding eigenvector by forming a rank revealing twisted factorization. Go back to (c) for any clusters that remain. For more details, see: - Inderjit S. Dhillon and Beresford N. Parlett: "Multiple representations to compute orthogonal eigenvectors of symmetric tridiagonal matrices," Linear Algebra and its Applications, 387(1), pp. 1-28, August 2004. - Inderjit Dhillon and Beresford Parlett: "Orthogonal Eigenvectors and Relative Gaps," SIAM Journal on Matrix Analysis and Applications, Vol. 25, 2004. Also LAPACK Working Note 154. - Inderjit Dhillon: "A new O(n^2) algorithm for the symmetric tridiagonal eigenvalue/eigenvector problem", Computer Science Division Technical Report No. UCB/CSD-97-971, UC Berkeley, May 1997. Further Details 1.DSTEMR works only on machines which follow IEEE-754 floating-point standard in their handling of infinities and NaNs. This permits the use of efficient inner loops avoiding a check for zero divisors.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | jobz | |||
| character, | intent(in) | :: | range | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=dp), | intent(inout) | :: | d(*) | |||
| real(kind=dp), | intent(inout) | :: | e(*) | |||
| real(kind=dp), | intent(in) | :: | vl | |||
| real(kind=dp), | intent(in) | :: | vu | |||
| integer(kind=ilp), | intent(in) | :: | il | |||
| integer(kind=ilp), | intent(in) | :: | iu | |||
| integer(kind=ilp), | intent(out) | :: | m | |||
| real(kind=dp), | intent(out) | :: | w(*) | |||
| real(kind=dp), | intent(out) | :: | z(ldz,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldz | |||
| integer(kind=ilp), | intent(in) | :: | nzc | |||
| integer(kind=ilp), | intent(out) | :: | isuppz(*) | |||
| logical(kind=lk), | intent(inout) | :: | tryrac | |||
| real(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | iwork(*) | |||
| integer(kind=ilp), | intent(in) | :: | liwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
SSTEMR computes selected eigenvalues and, optionally, eigenvectors of a real symmetric tridiagonal matrix T. Any such unreduced matrix has a well defined set of pairwise different real eigenvalues, the corresponding real eigenvectors are pairwise orthogonal. The spectrum may be computed either completely or partially by specifying either an interval (VL,VU] or a range of indices IL:IU for the desired eigenvalues. Depending on the number of desired eigenvalues, these are computed either by bisection or the dqds algorithm. Numerically orthogonal eigenvectors are computed by the use of various suitable L D L^T factorizations near clusters of close eigenvalues (referred to as RRRs, Relatively Robust Representations). An informal sketch of the algorithm follows. For each unreduced block (submatrix) of T, (a) Compute T - sigma I = L D L^T, so that L and D define all the wanted eigenvalues to high relative accuracy. This means that small relative changes in the entries of D and L cause only small relative changes in the eigenvalues and eigenvectors. The standard (unfactored) representation of the tridiagonal matrix T does not have this property in general. (b) Compute the eigenvalues to suitable accuracy. If the eigenvectors are desired, the algorithm attains full accuracy of the computed eigenvalues only right before the corresponding vectors have to be computed, see steps c) and d). (c) For each cluster of close eigenvalues, select a new shift close to the cluster, find a new factorization, and refine the shifted eigenvalues to suitable accuracy. (d) For each eigenvalue with a large enough relative separation compute the corresponding eigenvector by forming a rank revealing twisted factorization. Go back to (c) for any clusters that remain. For more details, see: - Inderjit S. Dhillon and Beresford N. Parlett: "Multiple representations to compute orthogonal eigenvectors of symmetric tridiagonal matrices," Linear Algebra and its Applications, 387(1), pp. 1-28, August 2004. - Inderjit Dhillon and Beresford Parlett: "Orthogonal Eigenvectors and Relative Gaps," SIAM Journal on Matrix Analysis and Applications, Vol. 25, 2004. Also LAPACK Working Note 154. - Inderjit Dhillon: "A new O(n^2) algorithm for the symmetric tridiagonal eigenvalue/eigenvector problem", Computer Science Division Technical Report No. UCB/CSD-97-971, UC Berkeley, May 1997. Further Details 1.SSTEMR works only on machines which follow IEEE-754 floating-point standard in their handling of infinities and NaNs. This permits the use of efficient inner loops avoiding a check for zero divisors.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | jobz | |||
| character, | intent(in) | :: | range | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=sp), | intent(inout) | :: | d(*) | |||
| real(kind=sp), | intent(inout) | :: | e(*) | |||
| real(kind=sp), | intent(in) | :: | vl | |||
| real(kind=sp), | intent(in) | :: | vu | |||
| integer(kind=ilp), | intent(in) | :: | il | |||
| integer(kind=ilp), | intent(in) | :: | iu | |||
| integer(kind=ilp), | intent(out) | :: | m | |||
| real(kind=sp), | intent(out) | :: | w(*) | |||
| real(kind=sp), | intent(out) | :: | z(ldz,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldz | |||
| integer(kind=ilp), | intent(in) | :: | nzc | |||
| integer(kind=ilp), | intent(out) | :: | isuppz(*) | |||
| logical(kind=lk), | intent(inout) | :: | tryrac | |||
| real(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | iwork(*) | |||
| integer(kind=ilp), | intent(in) | :: | liwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
ZSTEMR computes selected eigenvalues and, optionally, eigenvectors of a real symmetric tridiagonal matrix T. Any such unreduced matrix has a well defined set of pairwise different real eigenvalues, the corresponding real eigenvectors are pairwise orthogonal. The spectrum may be computed either completely or partially by specifying either an interval (VL,VU] or a range of indices IL:IU for the desired eigenvalues. Depending on the number of desired eigenvalues, these are computed either by bisection or the dqds algorithm. Numerically orthogonal eigenvectors are computed by the use of various suitable L D L^T factorizations near clusters of close eigenvalues (referred to as RRRs, Relatively Robust Representations). An informal sketch of the algorithm follows. For each unreduced block (submatrix) of T, (a) Compute T - sigma I = L D L^T, so that L and D define all the wanted eigenvalues to high relative accuracy. This means that small relative changes in the entries of D and L cause only small relative changes in the eigenvalues and eigenvectors. The standard (unfactored) representation of the tridiagonal matrix T does not have this property in general. (b) Compute the eigenvalues to suitable accuracy. If the eigenvectors are desired, the algorithm attains full accuracy of the computed eigenvalues only right before the corresponding vectors have to be computed, see steps c) and d). (c) For each cluster of close eigenvalues, select a new shift close to the cluster, find a new factorization, and refine the shifted eigenvalues to suitable accuracy. (d) For each eigenvalue with a large enough relative separation compute the corresponding eigenvector by forming a rank revealing twisted factorization. Go back to (c) for any clusters that remain. For more details, see: - Inderjit S. Dhillon and Beresford N. Parlett: "Multiple representations to compute orthogonal eigenvectors of symmetric tridiagonal matrices," Linear Algebra and its Applications, 387(1), pp. 1-28, August 2004. - Inderjit Dhillon and Beresford Parlett: "Orthogonal Eigenvectors and Relative Gaps," SIAM Journal on Matrix Analysis and Applications, Vol. 25, 2004. Also LAPACK Working Note 154. - Inderjit Dhillon: "A new O(n^2) algorithm for the symmetric tridiagonal eigenvalue/eigenvector problem", Computer Science Division Technical Report No. UCB/CSD-97-971, UC Berkeley, May 1997. Further Details 1.ZSTEMR works only on machines which follow IEEE-754 floating-point standard in their handling of infinities and NaNs. This permits the use of efficient inner loops avoiding a check for zero divisors. 2. LAPACK routines can be used to reduce a complex Hermitean matrix to real symmetric tridiagonal form. (Any complex Hermitean tridiagonal matrix has real values on its diagonal and potentially complex numbers on its off-diagonals. By applying a similarity transform with an appropriate diagonal matrix diag(1,e^{i \phy_1}, ... , e^{i \phy_{n-1}}), the complex Hermitean matrix can be transformed into a real symmetric matrix and complex arithmetic can be entirely avoided.) While the eigenvectors of the real symmetric tridiagonal matrix are real, the eigenvectors of original complex Hermitean matrix have complex entries in general. Since LAPACK drivers overwrite the matrix data with the eigenvectors, ZSTEMR accepts complex workspace to facilitate interoperability with ZUNMTR or ZUPMTR.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | jobz | |||
| character, | intent(in) | :: | range | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=dp), | intent(inout) | :: | d(*) | |||
| real(kind=dp), | intent(inout) | :: | e(*) | |||
| real(kind=dp), | intent(in) | :: | vl | |||
| real(kind=dp), | intent(in) | :: | vu | |||
| integer(kind=ilp), | intent(in) | :: | il | |||
| integer(kind=ilp), | intent(in) | :: | iu | |||
| integer(kind=ilp), | intent(out) | :: | m | |||
| real(kind=dp), | intent(out) | :: | w(*) | |||
| complex(kind=dp), | intent(out) | :: | z(ldz,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldz | |||
| integer(kind=ilp), | intent(in) | :: | nzc | |||
| integer(kind=ilp), | intent(out) | :: | isuppz(*) | |||
| logical(kind=lk), | intent(inout) | :: | tryrac | |||
| real(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | iwork(*) | |||
| integer(kind=ilp), | intent(in) | :: | liwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
STEQR computes all eigenvalues and, optionally, eigenvectors of a symmetric tridiagonal matrix using the implicit QL or QR method. The eigenvectors of a full or band complex Hermitian matrix can also be found if CHETRD or CHPTRD or CHBTRD has been used to reduce this matrix to tridiagonal form.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | compz | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=sp), | intent(inout) | :: | d(*) | |||
| real(kind=sp), | intent(inout) | :: | e(*) | |||
| complex(kind=sp), | intent(inout) | :: | z(ldz,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldz | |||
| real(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | compz | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=dp), | intent(inout) | :: | d(*) | |||
| real(kind=dp), | intent(inout) | :: | e(*) | |||
| real(kind=dp), | intent(inout) | :: | z(ldz,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldz | |||
| real(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | compz | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=sp), | intent(inout) | :: | d(*) | |||
| real(kind=sp), | intent(inout) | :: | e(*) | |||
| real(kind=sp), | intent(inout) | :: | z(ldz,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldz | |||
| real(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | compz | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=dp), | intent(inout) | :: | d(*) | |||
| real(kind=dp), | intent(inout) | :: | e(*) | |||
| complex(kind=dp), | intent(inout) | :: | z(ldz,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldz | |||
| real(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
CSTEQR computes all eigenvalues and, optionally, eigenvectors of a symmetric tridiagonal matrix using the implicit QL or QR method. The eigenvectors of a full or band complex Hermitian matrix can also be found if CHETRD or CHPTRD or CHBTRD has been used to reduce this matrix to tridiagonal form.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | compz | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=sp), | intent(inout) | :: | d(*) | |||
| real(kind=sp), | intent(inout) | :: | e(*) | |||
| complex(kind=sp), | intent(inout) | :: | z(ldz,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldz | |||
| real(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
DSTEQR computes all eigenvalues and, optionally, eigenvectors of a symmetric tridiagonal matrix using the implicit QL or QR method. The eigenvectors of a full or band symmetric matrix can also be found if DSYTRD or DSPTRD or DSBTRD has been used to reduce this matrix to tridiagonal form.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | compz | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=dp), | intent(inout) | :: | d(*) | |||
| real(kind=dp), | intent(inout) | :: | e(*) | |||
| real(kind=dp), | intent(inout) | :: | z(ldz,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldz | |||
| real(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
SSTEQR computes all eigenvalues and, optionally, eigenvectors of a symmetric tridiagonal matrix using the implicit QL or QR method. The eigenvectors of a full or band symmetric matrix can also be found if SSYTRD or SSPTRD or SSBTRD has been used to reduce this matrix to tridiagonal form.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | compz | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=sp), | intent(inout) | :: | d(*) | |||
| real(kind=sp), | intent(inout) | :: | e(*) | |||
| real(kind=sp), | intent(inout) | :: | z(ldz,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldz | |||
| real(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
ZSTEQR computes all eigenvalues and, optionally, eigenvectors of a symmetric tridiagonal matrix using the implicit QL or QR method. The eigenvectors of a full or band complex Hermitian matrix can also be found if ZHETRD or ZHPTRD or ZHBTRD has been used to reduce this matrix to tridiagonal form.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | compz | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=dp), | intent(inout) | :: | d(*) | |||
| real(kind=dp), | intent(inout) | :: | e(*) | |||
| complex(kind=dp), | intent(inout) | :: | z(ldz,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldz | |||
| real(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
STERF computes all eigenvalues of a symmetric tridiagonal matrix using the Pal-Walker-Kahan variant of the QL or QR algorithm.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=dp), | intent(inout) | :: | d(*) | |||
| real(kind=dp), | intent(inout) | :: | e(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=sp), | intent(inout) | :: | d(*) | |||
| real(kind=sp), | intent(inout) | :: | e(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
DSTERF computes all eigenvalues of a symmetric tridiagonal matrix using the Pal-Walker-Kahan variant of the QL or QR algorithm.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=dp), | intent(inout) | :: | d(*) | |||
| real(kind=dp), | intent(inout) | :: | e(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
SSTERF computes all eigenvalues of a symmetric tridiagonal matrix using the Pal-Walker-Kahan variant of the QL or QR algorithm.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=sp), | intent(inout) | :: | d(*) | |||
| real(kind=sp), | intent(inout) | :: | e(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
STEV computes all eigenvalues and, optionally, eigenvectors of a real symmetric tridiagonal matrix A.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | jobz | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=dp), | intent(inout) | :: | d(*) | |||
| real(kind=dp), | intent(inout) | :: | e(*) | |||
| real(kind=dp), | intent(out) | :: | z(ldz,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldz | |||
| real(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | jobz | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=sp), | intent(inout) | :: | d(*) | |||
| real(kind=sp), | intent(inout) | :: | e(*) | |||
| real(kind=sp), | intent(out) | :: | z(ldz,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldz | |||
| real(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
DSTEV computes all eigenvalues and, optionally, eigenvectors of a real symmetric tridiagonal matrix A.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | jobz | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=dp), | intent(inout) | :: | d(*) | |||
| real(kind=dp), | intent(inout) | :: | e(*) | |||
| real(kind=dp), | intent(out) | :: | z(ldz,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldz | |||
| real(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
SSTEV computes all eigenvalues and, optionally, eigenvectors of a real symmetric tridiagonal matrix A.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | jobz | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=sp), | intent(inout) | :: | d(*) | |||
| real(kind=sp), | intent(inout) | :: | e(*) | |||
| real(kind=sp), | intent(out) | :: | z(ldz,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldz | |||
| real(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
STEVD computes all eigenvalues and, optionally, eigenvectors of a real symmetric tridiagonal matrix. If eigenvectors are desired, it uses a divide and conquer algorithm. The divide and conquer algorithm makes very mild assumptions about floating point arithmetic. It will work on machines with a guard digit in add/subtract, or on those binary machines without guard digits which subtract like the Cray X-MP, Cray Y-MP, Cray C-90, or Cray-2. It could conceivably fail on hexadecimal or decimal machines without guard digits, but we know of none.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | jobz | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=dp), | intent(inout) | :: | d(*) | |||
| real(kind=dp), | intent(inout) | :: | e(*) | |||
| real(kind=dp), | intent(out) | :: | z(ldz,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldz | |||
| real(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | iwork(*) | |||
| integer(kind=ilp), | intent(in) | :: | liwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | jobz | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=sp), | intent(inout) | :: | d(*) | |||
| real(kind=sp), | intent(inout) | :: | e(*) | |||
| real(kind=sp), | intent(out) | :: | z(ldz,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldz | |||
| real(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | iwork(*) | |||
| integer(kind=ilp), | intent(in) | :: | liwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
DSTEVD computes all eigenvalues and, optionally, eigenvectors of a real symmetric tridiagonal matrix. If eigenvectors are desired, it uses a divide and conquer algorithm. The divide and conquer algorithm makes very mild assumptions about floating point arithmetic. It will work on machines with a guard digit in add/subtract, or on those binary machines without guard digits which subtract like the Cray X-MP, Cray Y-MP, Cray C-90, or Cray-2. It could conceivably fail on hexadecimal or decimal machines without guard digits, but we know of none.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | jobz | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=dp), | intent(inout) | :: | d(*) | |||
| real(kind=dp), | intent(inout) | :: | e(*) | |||
| real(kind=dp), | intent(out) | :: | z(ldz,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldz | |||
| real(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | iwork(*) | |||
| integer(kind=ilp), | intent(in) | :: | liwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
SSTEVD computes all eigenvalues and, optionally, eigenvectors of a real symmetric tridiagonal matrix. If eigenvectors are desired, it uses a divide and conquer algorithm. The divide and conquer algorithm makes very mild assumptions about floating point arithmetic. It will work on machines with a guard digit in add/subtract, or on those binary machines without guard digits which subtract like the Cray X-MP, Cray Y-MP, Cray C-90, or Cray-2. It could conceivably fail on hexadecimal or decimal machines without guard digits, but we know of none.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | jobz | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=sp), | intent(inout) | :: | d(*) | |||
| real(kind=sp), | intent(inout) | :: | e(*) | |||
| real(kind=sp), | intent(out) | :: | z(ldz,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldz | |||
| real(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | iwork(*) | |||
| integer(kind=ilp), | intent(in) | :: | liwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
STEVR computes selected eigenvalues and, optionally, eigenvectors of a real symmetric tridiagonal matrix T. Eigenvalues and eigenvectors can be selected by specifying either a range of values or a range of indices for the desired eigenvalues. Whenever possible, STEVR calls DSTEMR to compute the eigenspectrum using Relatively Robust Representations. DSTEMR computes eigenvalues by the dqds algorithm, while orthogonal eigenvectors are computed from various "good" L D L^T representations (also known as Relatively Robust Representations). Gram-Schmidt orthogonalization is avoided as far as possible. More specifically, the various steps of the algorithm are as follows. For the i-th unreduced block of T, (a) Compute T - sigma_i = L_i D_i L_i^T, such that L_i D_i L_i^T is a relatively robust representation, (b) Compute the eigenvalues, lambda_j, of L_i D_i L_i^T to high relative accuracy by the dqds algorithm, (c) If there is a cluster of close eigenvalues, "choose" sigma_i close to the cluster, and go to step (a), (d) Given the approximate eigenvalue lambda_j of L_i D_i L_i^T, compute the corresponding eigenvector by forming a rank-revealing twisted factorization. The desired accuracy of the output can be specified by the input parameter ABSTOL. For more details, see "A new O(n^2) algorithm for the symmetric tridiagonal eigenvalue/eigenvector problem", by Inderjit Dhillon, Computer Science Division Technical Report No. UCB//CSD-97-971, UC Berkeley, May 1997. Note 1 : STEVR calls DSTEMR when the full spectrum is requested on machines which conform to the ieee-754 floating point standard. STEVR calls DSTEBZ and DSTEIN on non-ieee machines and when partial spectrum requests are made. Normal execution of DSTEMR may create NaNs and infinities and hence may abort due to a floating point exception in environments which do not handle NaNs and infinities in the ieee standard default manner.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | jobz | |||
| character, | intent(in) | :: | range | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=dp), | intent(inout) | :: | d(*) | |||
| real(kind=dp), | intent(inout) | :: | e(*) | |||
| real(kind=dp), | intent(in) | :: | vl | |||
| real(kind=dp), | intent(in) | :: | vu | |||
| integer(kind=ilp), | intent(in) | :: | il | |||
| integer(kind=ilp), | intent(in) | :: | iu | |||
| real(kind=dp), | intent(in) | :: | abstol | |||
| integer(kind=ilp), | intent(out) | :: | m | |||
| real(kind=dp), | intent(out) | :: | w(*) | |||
| real(kind=dp), | intent(out) | :: | z(ldz,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldz | |||
| integer(kind=ilp), | intent(out) | :: | isuppz(*) | |||
| real(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | iwork(*) | |||
| integer(kind=ilp), | intent(in) | :: | liwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | jobz | |||
| character, | intent(in) | :: | range | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=sp), | intent(inout) | :: | d(*) | |||
| real(kind=sp), | intent(inout) | :: | e(*) | |||
| real(kind=sp), | intent(in) | :: | vl | |||
| real(kind=sp), | intent(in) | :: | vu | |||
| integer(kind=ilp), | intent(in) | :: | il | |||
| integer(kind=ilp), | intent(in) | :: | iu | |||
| real(kind=sp), | intent(in) | :: | abstol | |||
| integer(kind=ilp), | intent(out) | :: | m | |||
| real(kind=sp), | intent(out) | :: | w(*) | |||
| real(kind=sp), | intent(out) | :: | z(ldz,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldz | |||
| integer(kind=ilp), | intent(out) | :: | isuppz(*) | |||
| real(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | iwork(*) | |||
| integer(kind=ilp), | intent(in) | :: | liwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
DSTEVR computes selected eigenvalues and, optionally, eigenvectors of a real symmetric tridiagonal matrix T. Eigenvalues and eigenvectors can be selected by specifying either a range of values or a range of indices for the desired eigenvalues. Whenever possible, DSTEVR calls DSTEMR to compute the eigenspectrum using Relatively Robust Representations. DSTEMR computes eigenvalues by the dqds algorithm, while orthogonal eigenvectors are computed from various "good" L D L^T representations (also known as Relatively Robust Representations). Gram-Schmidt orthogonalization is avoided as far as possible. More specifically, the various steps of the algorithm are as follows. For the i-th unreduced block of T, (a) Compute T - sigma_i = L_i D_i L_i^T, such that L_i D_i L_i^T is a relatively robust representation, (b) Compute the eigenvalues, lambda_j, of L_i D_i L_i^T to high relative accuracy by the dqds algorithm, (c) If there is a cluster of close eigenvalues, "choose" sigma_i close to the cluster, and go to step (a), (d) Given the approximate eigenvalue lambda_j of L_i D_i L_i^T, compute the corresponding eigenvector by forming a rank-revealing twisted factorization. The desired accuracy of the output can be specified by the input parameter ABSTOL. For more details, see "A new O(n^2) algorithm for the symmetric tridiagonal eigenvalue/eigenvector problem", by Inderjit Dhillon, Computer Science Division Technical Report No. UCB//CSD-97-971, UC Berkeley, May 1997. Note 1 : DSTEVR calls DSTEMR when the full spectrum is requested on machines which conform to the ieee-754 floating point standard. DSTEVR calls DSTEBZ and DSTEIN on non-ieee machines and when partial spectrum requests are made. Normal execution of DSTEMR may create NaNs and infinities and hence may abort due to a floating point exception in environments which do not handle NaNs and infinities in the ieee standard default manner.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | jobz | |||
| character, | intent(in) | :: | range | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=dp), | intent(inout) | :: | d(*) | |||
| real(kind=dp), | intent(inout) | :: | e(*) | |||
| real(kind=dp), | intent(in) | :: | vl | |||
| real(kind=dp), | intent(in) | :: | vu | |||
| integer(kind=ilp), | intent(in) | :: | il | |||
| integer(kind=ilp), | intent(in) | :: | iu | |||
| real(kind=dp), | intent(in) | :: | abstol | |||
| integer(kind=ilp), | intent(out) | :: | m | |||
| real(kind=dp), | intent(out) | :: | w(*) | |||
| real(kind=dp), | intent(out) | :: | z(ldz,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldz | |||
| integer(kind=ilp), | intent(out) | :: | isuppz(*) | |||
| real(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | iwork(*) | |||
| integer(kind=ilp), | intent(in) | :: | liwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
SSTEVR computes selected eigenvalues and, optionally, eigenvectors of a real symmetric tridiagonal matrix T. Eigenvalues and eigenvectors can be selected by specifying either a range of values or a range of indices for the desired eigenvalues. Whenever possible, SSTEVR calls SSTEMR to compute the eigenspectrum using Relatively Robust Representations. SSTEMR computes eigenvalues by the dqds algorithm, while orthogonal eigenvectors are computed from various "good" L D L^T representations (also known as Relatively Robust Representations). Gram-Schmidt orthogonalization is avoided as far as possible. More specifically, the various steps of the algorithm are as follows. For the i-th unreduced block of T, (a) Compute T - sigma_i = L_i D_i L_i^T, such that L_i D_i L_i^T is a relatively robust representation, (b) Compute the eigenvalues, lambda_j, of L_i D_i L_i^T to high relative accuracy by the dqds algorithm, (c) If there is a cluster of close eigenvalues, "choose" sigma_i close to the cluster, and go to step (a), (d) Given the approximate eigenvalue lambda_j of L_i D_i L_i^T, compute the corresponding eigenvector by forming a rank-revealing twisted factorization. The desired accuracy of the output can be specified by the input parameter ABSTOL. For more details, see "A new O(n^2) algorithm for the symmetric tridiagonal eigenvalue/eigenvector problem", by Inderjit Dhillon, Computer Science Division Technical Report No. UCB//CSD-97-971, UC Berkeley, May 1997. Note 1 : SSTEVR calls SSTEMR when the full spectrum is requested on machines which conform to the ieee-754 floating point standard. SSTEVR calls SSTEBZ and SSTEIN on non-ieee machines and when partial spectrum requests are made. Normal execution of SSTEMR may create NaNs and infinities and hence may abort due to a floating point exception in environments which do not handle NaNs and infinities in the ieee standard default manner.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | jobz | |||
| character, | intent(in) | :: | range | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=sp), | intent(inout) | :: | d(*) | |||
| real(kind=sp), | intent(inout) | :: | e(*) | |||
| real(kind=sp), | intent(in) | :: | vl | |||
| real(kind=sp), | intent(in) | :: | vu | |||
| integer(kind=ilp), | intent(in) | :: | il | |||
| integer(kind=ilp), | intent(in) | :: | iu | |||
| real(kind=sp), | intent(in) | :: | abstol | |||
| integer(kind=ilp), | intent(out) | :: | m | |||
| real(kind=sp), | intent(out) | :: | w(*) | |||
| real(kind=sp), | intent(out) | :: | z(ldz,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldz | |||
| integer(kind=ilp), | intent(out) | :: | isuppz(*) | |||
| real(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | iwork(*) | |||
| integer(kind=ilp), | intent(in) | :: | liwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
SYCON estimates the reciprocal of the condition number (in the 1-norm) of a complex symmetric matrix A using the factorization A = UDUT or A = LDLT computed by CSYTRF. An estimate is obtained for norm(inv(A)), and the reciprocal of the condition number is computed as RCOND = 1 / (ANORM * norm(inv(A))).
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=sp), | intent(in) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| integer(kind=ilp), | intent(in) | :: | ipiv(*) | |||
| real(kind=sp), | intent(in) | :: | anorm | |||
| real(kind=sp), | intent(out) | :: | rcond | |||
| complex(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=dp), | intent(in) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| integer(kind=ilp), | intent(in) | :: | ipiv(*) | |||
| real(kind=dp), | intent(in) | :: | anorm | |||
| real(kind=dp), | intent(out) | :: | rcond | |||
| real(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | iwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=sp), | intent(in) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| integer(kind=ilp), | intent(in) | :: | ipiv(*) | |||
| real(kind=sp), | intent(in) | :: | anorm | |||
| real(kind=sp), | intent(out) | :: | rcond | |||
| real(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | iwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=dp), | intent(in) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| integer(kind=ilp), | intent(in) | :: | ipiv(*) | |||
| real(kind=dp), | intent(in) | :: | anorm | |||
| real(kind=dp), | intent(out) | :: | rcond | |||
| complex(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
CSYCON estimates the reciprocal of the condition number (in the 1-norm) of a complex symmetric matrix A using the factorization A = UDUT or A = LDLT computed by CSYTRF. An estimate is obtained for norm(inv(A)), and the reciprocal of the condition number is computed as RCOND = 1 / (ANORM * norm(inv(A))).
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=sp), | intent(in) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| integer(kind=ilp), | intent(in) | :: | ipiv(*) | |||
| real(kind=sp), | intent(in) | :: | anorm | |||
| real(kind=sp), | intent(out) | :: | rcond | |||
| complex(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
DSYCON estimates the reciprocal of the condition number (in the 1-norm) of a real symmetric matrix A using the factorization A = UDUT or A = LDLT computed by DSYTRF. An estimate is obtained for norm(inv(A)), and the reciprocal of the condition number is computed as RCOND = 1 / (ANORM * norm(inv(A))).
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=dp), | intent(in) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| integer(kind=ilp), | intent(in) | :: | ipiv(*) | |||
| real(kind=dp), | intent(in) | :: | anorm | |||
| real(kind=dp), | intent(out) | :: | rcond | |||
| real(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | iwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
SSYCON estimates the reciprocal of the condition number (in the 1-norm) of a real symmetric matrix A using the factorization A = UDUT or A = LDLT computed by SSYTRF. An estimate is obtained for norm(inv(A)), and the reciprocal of the condition number is computed as RCOND = 1 / (ANORM * norm(inv(A))).
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=sp), | intent(in) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| integer(kind=ilp), | intent(in) | :: | ipiv(*) | |||
| real(kind=sp), | intent(in) | :: | anorm | |||
| real(kind=sp), | intent(out) | :: | rcond | |||
| real(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | iwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
ZSYCON estimates the reciprocal of the condition number (in the 1-norm) of a complex symmetric matrix A using the factorization A = UDUT or A = LDLT computed by ZSYTRF. An estimate is obtained for norm(inv(A)), and the reciprocal of the condition number is computed as RCOND = 1 / (ANORM * norm(inv(A))).
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=dp), | intent(in) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| integer(kind=ilp), | intent(in) | :: | ipiv(*) | |||
| real(kind=dp), | intent(in) | :: | anorm | |||
| real(kind=dp), | intent(out) | :: | rcond | |||
| complex(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
SYCON_ROOK estimates the reciprocal of the condition number (in the 1-norm) of a complex symmetric matrix A using the factorization A = UDUT or A = LDLT computed by CSYTRF_ROOK. An estimate is obtained for norm(inv(A)), and the reciprocal of the condition number is computed as RCOND = 1 / (ANORM * norm(inv(A))).
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=sp), | intent(in) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| integer(kind=ilp), | intent(in) | :: | ipiv(*) | |||
| real(kind=sp), | intent(in) | :: | anorm | |||
| real(kind=sp), | intent(out) | :: | rcond | |||
| complex(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=dp), | intent(in) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| integer(kind=ilp), | intent(in) | :: | ipiv(*) | |||
| real(kind=dp), | intent(in) | :: | anorm | |||
| real(kind=dp), | intent(out) | :: | rcond | |||
| real(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | iwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=sp), | intent(in) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| integer(kind=ilp), | intent(in) | :: | ipiv(*) | |||
| real(kind=sp), | intent(in) | :: | anorm | |||
| real(kind=sp), | intent(out) | :: | rcond | |||
| real(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | iwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=dp), | intent(in) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| integer(kind=ilp), | intent(in) | :: | ipiv(*) | |||
| real(kind=dp), | intent(in) | :: | anorm | |||
| real(kind=dp), | intent(out) | :: | rcond | |||
| complex(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
CSYCON_ROOK estimates the reciprocal of the condition number (in the 1-norm) of a complex symmetric matrix A using the factorization A = UDUT or A = LDLT computed by CSYTRF_ROOK. An estimate is obtained for norm(inv(A)), and the reciprocal of the condition number is computed as RCOND = 1 / (ANORM * norm(inv(A))).
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=sp), | intent(in) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| integer(kind=ilp), | intent(in) | :: | ipiv(*) | |||
| real(kind=sp), | intent(in) | :: | anorm | |||
| real(kind=sp), | intent(out) | :: | rcond | |||
| complex(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
DSYCON_ROOK estimates the reciprocal of the condition number (in the 1-norm) of a real symmetric matrix A using the factorization A = UDUT or A = LDLT computed by DSYTRF_ROOK. An estimate is obtained for norm(inv(A)), and the reciprocal of the condition number is computed as RCOND = 1 / (ANORM * norm(inv(A))).
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=dp), | intent(in) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| integer(kind=ilp), | intent(in) | :: | ipiv(*) | |||
| real(kind=dp), | intent(in) | :: | anorm | |||
| real(kind=dp), | intent(out) | :: | rcond | |||
| real(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | iwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
SSYCON_ROOK estimates the reciprocal of the condition number (in the 1-norm) of a real symmetric matrix A using the factorization A = UDUT or A = LDLT computed by SSYTRF_ROOK. An estimate is obtained for norm(inv(A)), and the reciprocal of the condition number is computed as RCOND = 1 / (ANORM * norm(inv(A))).
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=sp), | intent(in) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| integer(kind=ilp), | intent(in) | :: | ipiv(*) | |||
| real(kind=sp), | intent(in) | :: | anorm | |||
| real(kind=sp), | intent(out) | :: | rcond | |||
| real(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | iwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
ZSYCON_ROOK estimates the reciprocal of the condition number (in the 1-norm) of a complex symmetric matrix A using the factorization A = UDUT or A = LDLT computed by ZSYTRF_ROOK. An estimate is obtained for norm(inv(A)), and the reciprocal of the condition number is computed as RCOND = 1 / (ANORM * norm(inv(A))).
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=dp), | intent(in) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| integer(kind=ilp), | intent(in) | :: | ipiv(*) | |||
| real(kind=dp), | intent(in) | :: | anorm | |||
| real(kind=dp), | intent(out) | :: | rcond | |||
| complex(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
SYCONV convert A given by TRF into L and D and vice-versa. Get Non-diag elements of D (returned in workspace) and apply or reverse permutation done in TRF.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| character, | intent(in) | :: | way | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| integer(kind=ilp), | intent(in) | :: | ipiv(*) | |||
| complex(kind=sp), | intent(out) | :: | e(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| character, | intent(in) | :: | way | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| integer(kind=ilp), | intent(in) | :: | ipiv(*) | |||
| real(kind=dp), | intent(out) | :: | e(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| character, | intent(in) | :: | way | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| integer(kind=ilp), | intent(in) | :: | ipiv(*) | |||
| real(kind=sp), | intent(out) | :: | e(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| character, | intent(in) | :: | way | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| integer(kind=ilp), | intent(in) | :: | ipiv(*) | |||
| complex(kind=dp), | intent(out) | :: | e(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
CSYCONV convert A given by TRF into L and D and vice-versa. Get Non-diag elements of D (returned in workspace) and apply or reverse permutation done in TRF.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| character, | intent(in) | :: | way | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| integer(kind=ilp), | intent(in) | :: | ipiv(*) | |||
| complex(kind=sp), | intent(out) | :: | e(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
DSYCONV convert A given by TRF into L and D and vice-versa. Get Non-diag elements of D (returned in workspace) and apply or reverse permutation done in TRF.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| character, | intent(in) | :: | way | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| integer(kind=ilp), | intent(in) | :: | ipiv(*) | |||
| real(kind=dp), | intent(out) | :: | e(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
SSYCONV convert A given by TRF into L and D and vice-versa. Get Non-diag elements of D (returned in workspace) and apply or reverse permutation done in TRF.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| character, | intent(in) | :: | way | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| integer(kind=ilp), | intent(in) | :: | ipiv(*) | |||
| real(kind=sp), | intent(out) | :: | e(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
ZSYCONV converts A given by ZHETRF into L and D or vice-versa. Get nondiagonal elements of D (returned in workspace) and apply or reverse permutation done in TRF.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| character, | intent(in) | :: | way | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| integer(kind=ilp), | intent(in) | :: | ipiv(*) | |||
| complex(kind=dp), | intent(out) | :: | e(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
If parameter WAY = 'C': SYCONVF converts the factorization output format used in CSYTRF provided on entry in parameter A into the factorization output format used in CSYTRF_RK (or CSYTRF_BK) that is stored on exit in parameters A and E. It also converts in place details of the intechanges stored in IPIV from the format used in CSYTRF into the format used in CSYTRF_RK (or CSYTRF_BK). If parameter WAY = 'R': SYCONVF performs the conversion in reverse direction, i.e. converts the factorization output format used in CSYTRF_RK (or CSYTRF_BK) provided on entry in parameters A and E into the factorization output format used in CSYTRF that is stored on exit in parameter A. It also converts in place details of the intechanges stored in IPIV from the format used in CSYTRF_RK (or CSYTRF_BK) into the format used in CSYTRF. SYCONVF can also convert in Hermitian matrix case, i.e. between formats used in CHETRF and CHETRF_RK (or CHETRF_BK).
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| character, | intent(in) | :: | way | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=sp), | intent(inout) | :: | e(*) | |||
| integer(kind=ilp), | intent(inout) | :: | ipiv(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| character, | intent(in) | :: | way | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=dp), | intent(inout) | :: | e(*) | |||
| integer(kind=ilp), | intent(inout) | :: | ipiv(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| character, | intent(in) | :: | way | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=sp), | intent(inout) | :: | e(*) | |||
| integer(kind=ilp), | intent(inout) | :: | ipiv(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| character, | intent(in) | :: | way | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=dp), | intent(inout) | :: | e(*) | |||
| integer(kind=ilp), | intent(inout) | :: | ipiv(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
If parameter WAY = 'C': CSYCONVF converts the factorization output format used in CSYTRF provided on entry in parameter A into the factorization output format used in CSYTRF_RK (or CSYTRF_BK) that is stored on exit in parameters A and E. It also converts in place details of the intechanges stored in IPIV from the format used in CSYTRF into the format used in CSYTRF_RK (or CSYTRF_BK). If parameter WAY = 'R': CSYCONVF performs the conversion in reverse direction, i.e. converts the factorization output format used in CSYTRF_RK (or CSYTRF_BK) provided on entry in parameters A and E into the factorization output format used in CSYTRF that is stored on exit in parameter A. It also converts in place details of the intechanges stored in IPIV from the format used in CSYTRF_RK (or CSYTRF_BK) into the format used in CSYTRF. CSYCONVF can also convert in Hermitian matrix case, i.e. between formats used in CHETRF and CHETRF_RK (or CHETRF_BK).
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| character, | intent(in) | :: | way | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=sp), | intent(inout) | :: | e(*) | |||
| integer(kind=ilp), | intent(inout) | :: | ipiv(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
If parameter WAY = 'C': DSYCONVF converts the factorization output format used in DSYTRF provided on entry in parameter A into the factorization output format used in DSYTRF_RK (or DSYTRF_BK) that is stored on exit in parameters A and E. It also converts in place details of the intechanges stored in IPIV from the format used in DSYTRF into the format used in DSYTRF_RK (or DSYTRF_BK). If parameter WAY = 'R': DSYCONVF performs the conversion in reverse direction, i.e. converts the factorization output format used in DSYTRF_RK (or DSYTRF_BK) provided on entry in parameters A and E into the factorization output format used in DSYTRF that is stored on exit in parameter A. It also converts in place details of the intechanges stored in IPIV from the format used in DSYTRF_RK (or DSYTRF_BK) into the format used in DSYTRF.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| character, | intent(in) | :: | way | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=dp), | intent(inout) | :: | e(*) | |||
| integer(kind=ilp), | intent(inout) | :: | ipiv(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
If parameter WAY = 'C': SSYCONVF converts the factorization output format used in SSYTRF provided on entry in parameter A into the factorization output format used in SSYTRF_RK (or SSYTRF_BK) that is stored on exit in parameters A and E. It also converts in place details of the intechanges stored in IPIV from the format used in SSYTRF into the format used in SSYTRF_RK (or SSYTRF_BK). If parameter WAY = 'R': SSYCONVF performs the conversion in reverse direction, i.e. converts the factorization output format used in SSYTRF_RK (or SSYTRF_BK) provided on entry in parameters A and E into the factorization output format used in SSYTRF that is stored on exit in parameter A. It also converts in place details of the intechanges stored in IPIV from the format used in SSYTRF_RK (or SSYTRF_BK) into the format used in SSYTRF.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| character, | intent(in) | :: | way | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=sp), | intent(inout) | :: | e(*) | |||
| integer(kind=ilp), | intent(inout) | :: | ipiv(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
If parameter WAY = 'C': ZSYCONVF converts the factorization output format used in ZSYTRF provided on entry in parameter A into the factorization output format used in ZSYTRF_RK (or ZSYTRF_BK) that is stored on exit in parameters A and E. It also converts in place details of the intechanges stored in IPIV from the format used in ZSYTRF into the format used in ZSYTRF_RK (or ZSYTRF_BK). If parameter WAY = 'R': ZSYCONVF performs the conversion in reverse direction, i.e. converts the factorization output format used in ZSYTRF_RK (or ZSYTRF_BK) provided on entry in parameters A and E into the factorization output format used in ZSYTRF that is stored on exit in parameter A. It also converts in place details of the intechanges stored in IPIV from the format used in ZSYTRF_RK (or ZSYTRF_BK) into the format used in ZSYTRF. ZSYCONVF can also convert in Hermitian matrix case, i.e. between formats used in ZHETRF and ZHETRF_RK (or ZHETRF_BK).
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| character, | intent(in) | :: | way | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=dp), | intent(inout) | :: | e(*) | |||
| integer(kind=ilp), | intent(inout) | :: | ipiv(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
If parameter WAY = 'C': SYCONVF_ROOK converts the factorization output format used in CSYTRF_ROOK provided on entry in parameter A into the factorization output format used in CSYTRF_RK (or CSYTRF_BK) that is stored on exit in parameters A and E. IPIV format for CSYTRF_ROOK and CSYTRF_RK (or CSYTRF_BK) is the same and is not converted. If parameter WAY = 'R': SYCONVF_ROOK performs the conversion in reverse direction, i.e. converts the factorization output format used in CSYTRF_RK (or CSYTRF_BK) provided on entry in parameters A and E into the factorization output format used in CSYTRF_ROOK that is stored on exit in parameter A. IPIV format for CSYTRF_ROOK and CSYTRF_RK (or CSYTRF_BK) is the same and is not converted. SYCONVF_ROOK can also convert in Hermitian matrix case, i.e. between formats used in CHETRF_ROOK and CHETRF_RK (or CHETRF_BK).
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| character, | intent(in) | :: | way | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=sp), | intent(inout) | :: | e(*) | |||
| integer(kind=ilp), | intent(in) | :: | ipiv(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| character, | intent(in) | :: | way | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=dp), | intent(inout) | :: | e(*) | |||
| integer(kind=ilp), | intent(in) | :: | ipiv(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| character, | intent(in) | :: | way | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=sp), | intent(inout) | :: | e(*) | |||
| integer(kind=ilp), | intent(in) | :: | ipiv(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| character, | intent(in) | :: | way | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=dp), | intent(inout) | :: | e(*) | |||
| integer(kind=ilp), | intent(in) | :: | ipiv(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
If parameter WAY = 'C': CSYCONVF_ROOK converts the factorization output format used in CSYTRF_ROOK provided on entry in parameter A into the factorization output format used in CSYTRF_RK (or CSYTRF_BK) that is stored on exit in parameters A and E. IPIV format for CSYTRF_ROOK and CSYTRF_RK (or CSYTRF_BK) is the same and is not converted. If parameter WAY = 'R': CSYCONVF_ROOK performs the conversion in reverse direction, i.e. converts the factorization output format used in CSYTRF_RK (or CSYTRF_BK) provided on entry in parameters A and E into the factorization output format used in CSYTRF_ROOK that is stored on exit in parameter A. IPIV format for CSYTRF_ROOK and CSYTRF_RK (or CSYTRF_BK) is the same and is not converted. CSYCONVF_ROOK can also convert in Hermitian matrix case, i.e. between formats used in CHETRF_ROOK and CHETRF_RK (or CHETRF_BK).
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| character, | intent(in) | :: | way | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=sp), | intent(inout) | :: | e(*) | |||
| integer(kind=ilp), | intent(in) | :: | ipiv(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
If parameter WAY = 'C': DSYCONVF_ROOK converts the factorization output format used in DSYTRF_ROOK provided on entry in parameter A into the factorization output format used in DSYTRF_RK (or DSYTRF_BK) that is stored on exit in parameters A and E. IPIV format for DSYTRF_ROOK and DSYTRF_RK (or DSYTRF_BK) is the same and is not converted. If parameter WAY = 'R': DSYCONVF_ROOK performs the conversion in reverse direction, i.e. converts the factorization output format used in DSYTRF_RK (or DSYTRF_BK) provided on entry in parameters A and E into the factorization output format used in DSYTRF_ROOK that is stored on exit in parameter A. IPIV format for DSYTRF_ROOK and DSYTRF_RK (or DSYTRF_BK) is the same and is not converted.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| character, | intent(in) | :: | way | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=dp), | intent(inout) | :: | e(*) | |||
| integer(kind=ilp), | intent(in) | :: | ipiv(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
If parameter WAY = 'C': SSYCONVF_ROOK converts the factorization output format used in SSYTRF_ROOK provided on entry in parameter A into the factorization output format used in SSYTRF_RK (or SSYTRF_BK) that is stored on exit in parameters A and E. IPIV format for SSYTRF_ROOK and SSYTRF_RK (or SSYTRF_BK) is the same and is not converted. If parameter WAY = 'R': SSYCONVF_ROOK performs the conversion in reverse direction, i.e. converts the factorization output format used in SSYTRF_RK (or SSYTRF_BK) provided on entry in parameters A and E into the factorization output format used in SSYTRF_ROOK that is stored on exit in parameter A. IPIV format for SSYTRF_ROOK and SSYTRF_RK (or SSYTRF_BK) is the same and is not converted.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| character, | intent(in) | :: | way | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=sp), | intent(inout) | :: | e(*) | |||
| integer(kind=ilp), | intent(in) | :: | ipiv(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
If parameter WAY = 'C': ZSYCONVF_ROOK converts the factorization output format used in ZSYTRF_ROOK provided on entry in parameter A into the factorization output format used in ZSYTRF_RK (or ZSYTRF_BK) that is stored on exit in parameters A and E. IPIV format for ZSYTRF_ROOK and ZSYTRF_RK (or ZSYTRF_BK) is the same and is not converted. If parameter WAY = 'R': ZSYCONVF_ROOK performs the conversion in reverse direction, i.e. converts the factorization output format used in ZSYTRF_RK (or ZSYTRF_BK) provided on entry in parameters A and E into the factorization output format used in ZSYTRF_ROOK that is stored on exit in parameter A. IPIV format for ZSYTRF_ROOK and ZSYTRF_RK (or ZSYTRF_BK) is the same and is not converted. ZSYCONVF_ROOK can also convert in Hermitian matrix case, i.e. between formats used in ZHETRF_ROOK and ZHETRF_RK (or ZHETRF_BK).
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| character, | intent(in) | :: | way | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=dp), | intent(inout) | :: | e(*) | |||
| integer(kind=ilp), | intent(in) | :: | ipiv(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
SYEQUB computes row and column scalings intended to equilibrate a symmetric matrix A (with respect to the Euclidean norm) and reduce its condition number. The scale factors S are computed by the BIN algorithm (see references) so that the scaled matrix B with elements B(i,j) = S(i)A(i,j)S(j) has a condition number within a factor N of the smallest possible condition number over all possible diagonal scalings.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=sp), | intent(in) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=sp), | intent(out) | :: | s(*) | |||
| real(kind=sp), | intent(out) | :: | scond | |||
| real(kind=sp), | intent(out) | :: | amax | |||
| complex(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=dp), | intent(in) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=dp), | intent(out) | :: | s(*) | |||
| real(kind=dp), | intent(out) | :: | scond | |||
| real(kind=dp), | intent(out) | :: | amax | |||
| real(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=sp), | intent(in) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=sp), | intent(out) | :: | s(*) | |||
| real(kind=sp), | intent(out) | :: | scond | |||
| real(kind=sp), | intent(out) | :: | amax | |||
| real(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=dp), | intent(in) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=dp), | intent(out) | :: | s(*) | |||
| real(kind=dp), | intent(out) | :: | scond | |||
| real(kind=dp), | intent(out) | :: | amax | |||
| complex(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
CSYEQUB computes row and column scalings intended to equilibrate a symmetric matrix A (with respect to the Euclidean norm) and reduce its condition number. The scale factors S are computed by the BIN algorithm (see references) so that the scaled matrix B with elements B(i,j) = S(i)A(i,j)S(j) has a condition number within a factor N of the smallest possible condition number over all possible diagonal scalings.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=sp), | intent(in) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=sp), | intent(out) | :: | s(*) | |||
| real(kind=sp), | intent(out) | :: | scond | |||
| real(kind=sp), | intent(out) | :: | amax | |||
| complex(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
DSYEQUB computes row and column scalings intended to equilibrate a symmetric matrix A (with respect to the Euclidean norm) and reduce its condition number. The scale factors S are computed by the BIN algorithm (see references) so that the scaled matrix B with elements B(i,j) = S(i)A(i,j)S(j) has a condition number within a factor N of the smallest possible condition number over all possible diagonal scalings.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=dp), | intent(in) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=dp), | intent(out) | :: | s(*) | |||
| real(kind=dp), | intent(out) | :: | scond | |||
| real(kind=dp), | intent(out) | :: | amax | |||
| real(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
SSYEQUB computes row and column scalings intended to equilibrate a symmetric matrix A (with respect to the Euclidean norm) and reduce its condition number. The scale factors S are computed by the BIN algorithm (see references) so that the scaled matrix B with elements B(i,j) = S(i)A(i,j)S(j) has a condition number within a factor N of the smallest possible condition number over all possible diagonal scalings.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=sp), | intent(in) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=sp), | intent(out) | :: | s(*) | |||
| real(kind=sp), | intent(out) | :: | scond | |||
| real(kind=sp), | intent(out) | :: | amax | |||
| real(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
ZSYEQUB computes row and column scalings intended to equilibrate a symmetric matrix A (with respect to the Euclidean norm) and reduce its condition number. The scale factors S are computed by the BIN algorithm (see references) so that the scaled matrix B with elements B(i,j) = S(i)A(i,j)S(j) has a condition number within a factor N of the smallest possible condition number over all possible diagonal scalings.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=dp), | intent(in) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=dp), | intent(out) | :: | s(*) | |||
| real(kind=dp), | intent(out) | :: | scond | |||
| real(kind=dp), | intent(out) | :: | amax | |||
| complex(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
SYEV computes all eigenvalues and, optionally, eigenvectors of a real symmetric matrix A.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | jobz | |||
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=dp), | intent(out) | :: | w(*) | |||
| real(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | jobz | |||
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=sp), | intent(out) | :: | w(*) | |||
| real(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
DSYEV computes all eigenvalues and, optionally, eigenvectors of a real symmetric matrix A.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | jobz | |||
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=dp), | intent(out) | :: | w(*) | |||
| real(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
SSYEV computes all eigenvalues and, optionally, eigenvectors of a real symmetric matrix A.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | jobz | |||
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=sp), | intent(out) | :: | w(*) | |||
| real(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
SYEVD computes all eigenvalues and, optionally, eigenvectors of a real symmetric matrix A. If eigenvectors are desired, it uses a divide and conquer algorithm. The divide and conquer algorithm makes very mild assumptions about floating point arithmetic. It will work on machines with a guard digit in add/subtract, or on those binary machines without guard digits which subtract like the Cray X-MP, Cray Y-MP, Cray C-90, or Cray-2. It could conceivably fail on hexadecimal or decimal machines without guard digits, but we know of none. Because of large use of BLAS of level 3, SYEVD needs N**2 more workspace than DSYEVX.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | jobz | |||
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=dp), | intent(out) | :: | w(*) | |||
| real(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | iwork(*) | |||
| integer(kind=ilp), | intent(in) | :: | liwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | jobz | |||
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=sp), | intent(out) | :: | w(*) | |||
| real(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | iwork(*) | |||
| integer(kind=ilp), | intent(in) | :: | liwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
DSYEVD computes all eigenvalues and, optionally, eigenvectors of a real symmetric matrix A. If eigenvectors are desired, it uses a divide and conquer algorithm. The divide and conquer algorithm makes very mild assumptions about floating point arithmetic. It will work on machines with a guard digit in add/subtract, or on those binary machines without guard digits which subtract like the Cray X-MP, Cray Y-MP, Cray C-90, or Cray-2. It could conceivably fail on hexadecimal or decimal machines without guard digits, but we know of none. Because of large use of BLAS of level 3, DSYEVD needs N**2 more workspace than DSYEVX.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | jobz | |||
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=dp), | intent(out) | :: | w(*) | |||
| real(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | iwork(*) | |||
| integer(kind=ilp), | intent(in) | :: | liwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
SSYEVD computes all eigenvalues and, optionally, eigenvectors of a real symmetric matrix A. If eigenvectors are desired, it uses a divide and conquer algorithm. The divide and conquer algorithm makes very mild assumptions about floating point arithmetic. It will work on machines with a guard digit in add/subtract, or on those binary machines without guard digits which subtract like the Cray X-MP, Cray Y-MP, Cray C-90, or Cray-2. It could conceivably fail on hexadecimal or decimal machines without guard digits, but we know of none. Because of large use of BLAS of level 3, SSYEVD needs N**2 more workspace than SSYEVX.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | jobz | |||
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=sp), | intent(out) | :: | w(*) | |||
| real(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | iwork(*) | |||
| integer(kind=ilp), | intent(in) | :: | liwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
SYEVR computes selected eigenvalues and, optionally, eigenvectors of a real symmetric matrix A. Eigenvalues and eigenvectors can be selected by specifying either a range of values or a range of indices for the desired eigenvalues. SYEVR first reduces the matrix A to tridiagonal form T with a call to DSYTRD. Then, whenever possible, SYEVR calls DSTEMR to compute the eigenspectrum using Relatively Robust Representations. DSTEMR computes eigenvalues by the dqds algorithm, while orthogonal eigenvectors are computed from various "good" L D L^T representations (also known as Relatively Robust Representations). Gram-Schmidt orthogonalization is avoided as far as possible. More specifically, the various steps of the algorithm are as follows. For each unreduced block (submatrix) of T, (a) Compute T - sigma I = L D L^T, so that L and D define all the wanted eigenvalues to high relative accuracy. This means that small relative changes in the entries of D and L cause only small relative changes in the eigenvalues and eigenvectors. The standard (unfactored) representation of the tridiagonal matrix T does not have this property in general. (b) Compute the eigenvalues to suitable accuracy. If the eigenvectors are desired, the algorithm attains full accuracy of the computed eigenvalues only right before the corresponding vectors have to be computed, see steps c) and d). (c) For each cluster of close eigenvalues, select a new shift close to the cluster, find a new factorization, and refine the shifted eigenvalues to suitable accuracy. (d) For each eigenvalue with a large enough relative separation compute the corresponding eigenvector by forming a rank revealing twisted factorization. Go back to (c) for any clusters that remain. The desired accuracy of the output can be specified by the input parameter ABSTOL. For more details, see DSTEMR's documentation and: - Inderjit S. Dhillon and Beresford N. Parlett: "Multiple representations to compute orthogonal eigenvectors of symmetric tridiagonal matrices," Linear Algebra and its Applications, 387(1), pp. 1-28, August 2004. - Inderjit Dhillon and Beresford Parlett: "Orthogonal Eigenvectors and Relative Gaps," SIAM Journal on Matrix Analysis and Applications, Vol. 25, 2004. Also LAPACK Working Note 154. - Inderjit Dhillon: "A new O(n^2) algorithm for the symmetric tridiagonal eigenvalue/eigenvector problem", Computer Science Division Technical Report No. UCB/CSD-97-971, UC Berkeley, May 1997. Note 1 : SYEVR calls DSTEMR when the full spectrum is requested on machines which conform to the ieee-754 floating point standard. SYEVR calls DSTEBZ and DSTEIN on non-ieee machines and when partial spectrum requests are made. Normal execution of DSTEMR may create NaNs and infinities and hence may abort due to a floating point exception in environments which do not handle NaNs and infinities in the ieee standard default manner.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | jobz | |||
| character, | intent(in) | :: | range | |||
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=dp), | intent(in) | :: | vl | |||
| real(kind=dp), | intent(in) | :: | vu | |||
| integer(kind=ilp), | intent(in) | :: | il | |||
| integer(kind=ilp), | intent(in) | :: | iu | |||
| real(kind=dp), | intent(in) | :: | abstol | |||
| integer(kind=ilp), | intent(out) | :: | m | |||
| real(kind=dp), | intent(out) | :: | w(*) | |||
| real(kind=dp), | intent(out) | :: | z(ldz,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldz | |||
| integer(kind=ilp), | intent(out) | :: | isuppz(*) | |||
| real(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | iwork(*) | |||
| integer(kind=ilp), | intent(in) | :: | liwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | jobz | |||
| character, | intent(in) | :: | range | |||
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=sp), | intent(in) | :: | vl | |||
| real(kind=sp), | intent(in) | :: | vu | |||
| integer(kind=ilp), | intent(in) | :: | il | |||
| integer(kind=ilp), | intent(in) | :: | iu | |||
| real(kind=sp), | intent(in) | :: | abstol | |||
| integer(kind=ilp), | intent(out) | :: | m | |||
| real(kind=sp), | intent(out) | :: | w(*) | |||
| real(kind=sp), | intent(out) | :: | z(ldz,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldz | |||
| integer(kind=ilp), | intent(out) | :: | isuppz(*) | |||
| real(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | iwork(*) | |||
| integer(kind=ilp), | intent(in) | :: | liwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
DSYEVR computes selected eigenvalues and, optionally, eigenvectors of a real symmetric matrix A. Eigenvalues and eigenvectors can be selected by specifying either a range of values or a range of indices for the desired eigenvalues. DSYEVR first reduces the matrix A to tridiagonal form T with a call to DSYTRD. Then, whenever possible, DSYEVR calls DSTEMR to compute the eigenspectrum using Relatively Robust Representations. DSTEMR computes eigenvalues by the dqds algorithm, while orthogonal eigenvectors are computed from various "good" L D L^T representations (also known as Relatively Robust Representations). Gram-Schmidt orthogonalization is avoided as far as possible. More specifically, the various steps of the algorithm are as follows. For each unreduced block (submatrix) of T, (a) Compute T - sigma I = L D L^T, so that L and D define all the wanted eigenvalues to high relative accuracy. This means that small relative changes in the entries of D and L cause only small relative changes in the eigenvalues and eigenvectors. The standard (unfactored) representation of the tridiagonal matrix T does not have this property in general. (b) Compute the eigenvalues to suitable accuracy. If the eigenvectors are desired, the algorithm attains full accuracy of the computed eigenvalues only right before the corresponding vectors have to be computed, see steps c) and d). (c) For each cluster of close eigenvalues, select a new shift close to the cluster, find a new factorization, and refine the shifted eigenvalues to suitable accuracy. (d) For each eigenvalue with a large enough relative separation compute the corresponding eigenvector by forming a rank revealing twisted factorization. Go back to (c) for any clusters that remain. The desired accuracy of the output can be specified by the input parameter ABSTOL. For more details, see DSTEMR's documentation and: - Inderjit S. Dhillon and Beresford N. Parlett: "Multiple representations to compute orthogonal eigenvectors of symmetric tridiagonal matrices," Linear Algebra and its Applications, 387(1), pp. 1-28, August 2004. - Inderjit Dhillon and Beresford Parlett: "Orthogonal Eigenvectors and Relative Gaps," SIAM Journal on Matrix Analysis and Applications, Vol. 25, 2004. Also LAPACK Working Note 154. - Inderjit Dhillon: "A new O(n^2) algorithm for the symmetric tridiagonal eigenvalue/eigenvector problem", Computer Science Division Technical Report No. UCB/CSD-97-971, UC Berkeley, May 1997. Note 1 : DSYEVR calls DSTEMR when the full spectrum is requested on machines which conform to the ieee-754 floating point standard. DSYEVR calls DSTEBZ and DSTEIN on non-ieee machines and when partial spectrum requests are made. Normal execution of DSTEMR may create NaNs and infinities and hence may abort due to a floating point exception in environments which do not handle NaNs and infinities in the ieee standard default manner.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | jobz | |||
| character, | intent(in) | :: | range | |||
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=dp), | intent(in) | :: | vl | |||
| real(kind=dp), | intent(in) | :: | vu | |||
| integer(kind=ilp), | intent(in) | :: | il | |||
| integer(kind=ilp), | intent(in) | :: | iu | |||
| real(kind=dp), | intent(in) | :: | abstol | |||
| integer(kind=ilp), | intent(out) | :: | m | |||
| real(kind=dp), | intent(out) | :: | w(*) | |||
| real(kind=dp), | intent(out) | :: | z(ldz,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldz | |||
| integer(kind=ilp), | intent(out) | :: | isuppz(*) | |||
| real(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | iwork(*) | |||
| integer(kind=ilp), | intent(in) | :: | liwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
SSYEVR computes selected eigenvalues and, optionally, eigenvectors of a real symmetric matrix A. Eigenvalues and eigenvectors can be selected by specifying either a range of values or a range of indices for the desired eigenvalues. SSYEVR first reduces the matrix A to tridiagonal form T with a call to SSYTRD. Then, whenever possible, SSYEVR calls SSTEMR to compute the eigenspectrum using Relatively Robust Representations. SSTEMR computes eigenvalues by the dqds algorithm, while orthogonal eigenvectors are computed from various "good" L D L^T representations (also known as Relatively Robust Representations). Gram-Schmidt orthogonalization is avoided as far as possible. More specifically, the various steps of the algorithm are as follows. For each unreduced block (submatrix) of T, (a) Compute T - sigma I = L D L^T, so that L and D define all the wanted eigenvalues to high relative accuracy. This means that small relative changes in the entries of D and L cause only small relative changes in the eigenvalues and eigenvectors. The standard (unfactored) representation of the tridiagonal matrix T does not have this property in general. (b) Compute the eigenvalues to suitable accuracy. If the eigenvectors are desired, the algorithm attains full accuracy of the computed eigenvalues only right before the corresponding vectors have to be computed, see steps c) and d). (c) For each cluster of close eigenvalues, select a new shift close to the cluster, find a new factorization, and refine the shifted eigenvalues to suitable accuracy. (d) For each eigenvalue with a large enough relative separation compute the corresponding eigenvector by forming a rank revealing twisted factorization. Go back to (c) for any clusters that remain. The desired accuracy of the output can be specified by the input parameter ABSTOL. For more details, see SSTEMR's documentation and: - Inderjit S. Dhillon and Beresford N. Parlett: "Multiple representations to compute orthogonal eigenvectors of symmetric tridiagonal matrices," Linear Algebra and its Applications, 387(1), pp. 1-28, August 2004. - Inderjit Dhillon and Beresford Parlett: "Orthogonal Eigenvectors and Relative Gaps," SIAM Journal on Matrix Analysis and Applications, Vol. 25, 2004. Also LAPACK Working Note 154. - Inderjit Dhillon: "A new O(n^2) algorithm for the symmetric tridiagonal eigenvalue/eigenvector problem", Computer Science Division Technical Report No. UCB/CSD-97-971, UC Berkeley, May 1997. Note 1 : SSYEVR calls SSTEMR when the full spectrum is requested on machines which conform to the ieee-754 floating point standard. SSYEVR calls SSTEBZ and SSTEIN on non-ieee machines and when partial spectrum requests are made. Normal execution of SSTEMR may create NaNs and infinities and hence may abort due to a floating point exception in environments which do not handle NaNs and infinities in the ieee standard default manner.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | jobz | |||
| character, | intent(in) | :: | range | |||
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=sp), | intent(in) | :: | vl | |||
| real(kind=sp), | intent(in) | :: | vu | |||
| integer(kind=ilp), | intent(in) | :: | il | |||
| integer(kind=ilp), | intent(in) | :: | iu | |||
| real(kind=sp), | intent(in) | :: | abstol | |||
| integer(kind=ilp), | intent(out) | :: | m | |||
| real(kind=sp), | intent(out) | :: | w(*) | |||
| real(kind=sp), | intent(out) | :: | z(ldz,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldz | |||
| integer(kind=ilp), | intent(out) | :: | isuppz(*) | |||
| real(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | iwork(*) | |||
| integer(kind=ilp), | intent(in) | :: | liwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
SYGST reduces a real symmetric-definite generalized eigenproblem to standard form. If ITYPE = 1, the problem is Ax = lambdaBx, and A is overwritten by inv(UT)Ainv(U) or inv(L)Ainv(LT) If ITYPE = 2 or 3, the problem is ABx = lambdax or BAx = lambdax, and A is overwritten by UAUT or LTAL. B must have been previously factorized as UTU or LL*T by DPOTRF.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | itype | |||
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=dp), | intent(in) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | itype | |||
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=sp), | intent(in) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| integer(kind=ilp), | intent(out) | :: | info |
DSYGST reduces a real symmetric-definite generalized eigenproblem to standard form. If ITYPE = 1, the problem is Ax = lambdaBx, and A is overwritten by inv(UT)Ainv(U) or inv(L)Ainv(LT) If ITYPE = 2 or 3, the problem is ABx = lambdax or BAx = lambdax, and A is overwritten by UAUT or LTAL. B must have been previously factorized as UTU or LL*T by DPOTRF.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | itype | |||
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=dp), | intent(in) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| integer(kind=ilp), | intent(out) | :: | info |
SSYGST reduces a real symmetric-definite generalized eigenproblem to standard form. If ITYPE = 1, the problem is Ax = lambdaBx, and A is overwritten by inv(UT)Ainv(U) or inv(L)Ainv(LT) If ITYPE = 2 or 3, the problem is ABx = lambdax or BAx = lambdax, and A is overwritten by UAUT or LTAL. B must have been previously factorized as UTU or LL*T by SPOTRF.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | itype | |||
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=sp), | intent(in) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| integer(kind=ilp), | intent(out) | :: | info |
SYGV computes all the eigenvalues, and optionally, the eigenvectors of a real generalized symmetric-definite eigenproblem, of the form Ax=(lambda)Bx, ABx=(lambda)x, or BAx=(lambda)x. Here A and B are assumed to be symmetric and B is also positive definite.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | itype | |||
| character, | intent(in) | :: | jobz | |||
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=dp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| real(kind=dp), | intent(out) | :: | w(*) | |||
| real(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | itype | |||
| character, | intent(in) | :: | jobz | |||
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=sp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| real(kind=sp), | intent(out) | :: | w(*) | |||
| real(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
DSYGV computes all the eigenvalues, and optionally, the eigenvectors of a real generalized symmetric-definite eigenproblem, of the form Ax=(lambda)Bx, ABx=(lambda)x, or BAx=(lambda)x. Here A and B are assumed to be symmetric and B is also positive definite.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | itype | |||
| character, | intent(in) | :: | jobz | |||
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=dp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| real(kind=dp), | intent(out) | :: | w(*) | |||
| real(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
SSYGV computes all the eigenvalues, and optionally, the eigenvectors of a real generalized symmetric-definite eigenproblem, of the form Ax=(lambda)Bx, ABx=(lambda)x, or BAx=(lambda)x. Here A and B are assumed to be symmetric and B is also positive definite.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | itype | |||
| character, | intent(in) | :: | jobz | |||
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=sp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| real(kind=sp), | intent(out) | :: | w(*) | |||
| real(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
SYGVD computes all the eigenvalues, and optionally, the eigenvectors of a real generalized symmetric-definite eigenproblem, of the form Ax=(lambda)Bx, ABx=(lambda)x, or BAx=(lambda)x. Here A and B are assumed to be symmetric and B is also positive definite. If eigenvectors are desired, it uses a divide and conquer algorithm. The divide and conquer algorithm makes very mild assumptions about floating point arithmetic. It will work on machines with a guard digit in add/subtract, or on those binary machines without guard digits which subtract like the Cray X-MP, Cray Y-MP, Cray C-90, or Cray-2. It could conceivably fail on hexadecimal or decimal machines without guard digits, but we know of none.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | itype | |||
| character, | intent(in) | :: | jobz | |||
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=dp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| real(kind=dp), | intent(out) | :: | w(*) | |||
| real(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | iwork(*) | |||
| integer(kind=ilp), | intent(in) | :: | liwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | itype | |||
| character, | intent(in) | :: | jobz | |||
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=sp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| real(kind=sp), | intent(out) | :: | w(*) | |||
| real(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | iwork(*) | |||
| integer(kind=ilp), | intent(in) | :: | liwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
DSYGVD computes all the eigenvalues, and optionally, the eigenvectors of a real generalized symmetric-definite eigenproblem, of the form Ax=(lambda)Bx, ABx=(lambda)x, or BAx=(lambda)x. Here A and B are assumed to be symmetric and B is also positive definite. If eigenvectors are desired, it uses a divide and conquer algorithm. The divide and conquer algorithm makes very mild assumptions about floating point arithmetic. It will work on machines with a guard digit in add/subtract, or on those binary machines without guard digits which subtract like the Cray X-MP, Cray Y-MP, Cray C-90, or Cray-2. It could conceivably fail on hexadecimal or decimal machines without guard digits, but we know of none.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | itype | |||
| character, | intent(in) | :: | jobz | |||
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=dp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| real(kind=dp), | intent(out) | :: | w(*) | |||
| real(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | iwork(*) | |||
| integer(kind=ilp), | intent(in) | :: | liwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
SSYGVD computes all the eigenvalues, and optionally, the eigenvectors of a real generalized symmetric-definite eigenproblem, of the form Ax=(lambda)Bx, ABx=(lambda)x, or BAx=(lambda)x. Here A and B are assumed to be symmetric and B is also positive definite. If eigenvectors are desired, it uses a divide and conquer algorithm. The divide and conquer algorithm makes very mild assumptions about floating point arithmetic. It will work on machines with a guard digit in add/subtract, or on those binary machines without guard digits which subtract like the Cray X-MP, Cray Y-MP, Cray C-90, or Cray-2. It could conceivably fail on hexadecimal or decimal machines without guard digits, but we know of none.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | itype | |||
| character, | intent(in) | :: | jobz | |||
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=sp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| real(kind=sp), | intent(out) | :: | w(*) | |||
| real(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | iwork(*) | |||
| integer(kind=ilp), | intent(in) | :: | liwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
SYMV performs the matrix-vector operation y := alphaAx + beta*y, where alpha and beta are scalars, x and y are n element vectors and A is an n by n symmetric matrix.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=sp), | intent(in) | :: | alpha | |||
| complex(kind=sp), | intent(in) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=sp), | intent(in) | :: | x(*) | |||
| integer(kind=ilp), | intent(in) | :: | incx | |||
| complex(kind=sp), | intent(in) | :: | beta | |||
| complex(kind=sp), | intent(inout) | :: | y(*) | |||
| integer(kind=ilp), | intent(in) | :: | incy |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=dp), | intent(in) | :: | alpha | |||
| complex(kind=dp), | intent(in) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=dp), | intent(in) | :: | x(*) | |||
| integer(kind=ilp), | intent(in) | :: | incx | |||
| complex(kind=dp), | intent(in) | :: | beta | |||
| complex(kind=dp), | intent(inout) | :: | y(*) | |||
| integer(kind=ilp), | intent(in) | :: | incy |
CSYMV performs the matrix-vector operation y := alphaAx + beta*y, where alpha and beta are scalars, x and y are n element vectors and A is an n by n symmetric matrix.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=sp), | intent(in) | :: | alpha | |||
| complex(kind=sp), | intent(in) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=sp), | intent(in) | :: | x(*) | |||
| integer(kind=ilp), | intent(in) | :: | incx | |||
| complex(kind=sp), | intent(in) | :: | beta | |||
| complex(kind=sp), | intent(inout) | :: | y(*) | |||
| integer(kind=ilp), | intent(in) | :: | incy |
ZSYMV performs the matrix-vector operation y := alphaAx + beta*y, where alpha and beta are scalars, x and y are n element vectors and A is an n by n symmetric matrix.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=dp), | intent(in) | :: | alpha | |||
| complex(kind=dp), | intent(in) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=dp), | intent(in) | :: | x(*) | |||
| integer(kind=ilp), | intent(in) | :: | incx | |||
| complex(kind=dp), | intent(in) | :: | beta | |||
| complex(kind=dp), | intent(inout) | :: | y(*) | |||
| integer(kind=ilp), | intent(in) | :: | incy |
SYR performs the symmetric rank 1 operation A := alphaxx**H + A, where alpha is a complex scalar, x is an n element vector and A is an n by n symmetric matrix.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=sp), | intent(in) | :: | alpha | |||
| complex(kind=sp), | intent(in) | :: | x(*) | |||
| integer(kind=ilp), | intent(in) | :: | incx | |||
| complex(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=dp), | intent(in) | :: | alpha | |||
| complex(kind=dp), | intent(in) | :: | x(*) | |||
| integer(kind=ilp), | intent(in) | :: | incx | |||
| complex(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda |
CSYR performs the symmetric rank 1 operation A := alphaxx**H + A, where alpha is a complex scalar, x is an n element vector and A is an n by n symmetric matrix.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=sp), | intent(in) | :: | alpha | |||
| complex(kind=sp), | intent(in) | :: | x(*) | |||
| integer(kind=ilp), | intent(in) | :: | incx | |||
| complex(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda |
ZSYR performs the symmetric rank 1 operation A := alphaxx**H + A, where alpha is a complex scalar, x is an n element vector and A is an n by n symmetric matrix.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=dp), | intent(in) | :: | alpha | |||
| complex(kind=dp), | intent(in) | :: | x(*) | |||
| integer(kind=ilp), | intent(in) | :: | incx | |||
| complex(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda |
SYRFS improves the computed solution to a system of linear equations when the coefficient matrix is symmetric indefinite, and provides error bounds and backward error estimates for the solution.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| complex(kind=sp), | intent(in) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=sp), | intent(in) | :: | af(ldaf,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldaf | |||
| integer(kind=ilp), | intent(in) | :: | ipiv(*) | |||
| complex(kind=sp), | intent(in) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| complex(kind=sp), | intent(inout) | :: | x(ldx,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldx | |||
| real(kind=sp), | intent(out) | :: | ferr(*) | |||
| real(kind=sp), | intent(out) | :: | berr(*) | |||
| complex(kind=sp), | intent(out) | :: | work(*) | |||
| real(kind=sp), | intent(out) | :: | rwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| real(kind=dp), | intent(in) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=dp), | intent(in) | :: | af(ldaf,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldaf | |||
| integer(kind=ilp), | intent(in) | :: | ipiv(*) | |||
| real(kind=dp), | intent(in) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| real(kind=dp), | intent(inout) | :: | x(ldx,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldx | |||
| real(kind=dp), | intent(out) | :: | ferr(*) | |||
| real(kind=dp), | intent(out) | :: | berr(*) | |||
| real(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | iwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| real(kind=sp), | intent(in) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=sp), | intent(in) | :: | af(ldaf,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldaf | |||
| integer(kind=ilp), | intent(in) | :: | ipiv(*) | |||
| real(kind=sp), | intent(in) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| real(kind=sp), | intent(inout) | :: | x(ldx,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldx | |||
| real(kind=sp), | intent(out) | :: | ferr(*) | |||
| real(kind=sp), | intent(out) | :: | berr(*) | |||
| real(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | iwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| complex(kind=dp), | intent(in) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=dp), | intent(in) | :: | af(ldaf,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldaf | |||
| integer(kind=ilp), | intent(in) | :: | ipiv(*) | |||
| complex(kind=dp), | intent(in) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| complex(kind=dp), | intent(inout) | :: | x(ldx,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldx | |||
| real(kind=dp), | intent(out) | :: | ferr(*) | |||
| real(kind=dp), | intent(out) | :: | berr(*) | |||
| complex(kind=dp), | intent(out) | :: | work(*) | |||
| real(kind=dp), | intent(out) | :: | rwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
CSYRFS improves the computed solution to a system of linear equations when the coefficient matrix is symmetric indefinite, and provides error bounds and backward error estimates for the solution.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| complex(kind=sp), | intent(in) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=sp), | intent(in) | :: | af(ldaf,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldaf | |||
| integer(kind=ilp), | intent(in) | :: | ipiv(*) | |||
| complex(kind=sp), | intent(in) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| complex(kind=sp), | intent(inout) | :: | x(ldx,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldx | |||
| real(kind=sp), | intent(out) | :: | ferr(*) | |||
| real(kind=sp), | intent(out) | :: | berr(*) | |||
| complex(kind=sp), | intent(out) | :: | work(*) | |||
| real(kind=sp), | intent(out) | :: | rwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
DSYRFS improves the computed solution to a system of linear equations when the coefficient matrix is symmetric indefinite, and provides error bounds and backward error estimates for the solution.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| real(kind=dp), | intent(in) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=dp), | intent(in) | :: | af(ldaf,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldaf | |||
| integer(kind=ilp), | intent(in) | :: | ipiv(*) | |||
| real(kind=dp), | intent(in) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| real(kind=dp), | intent(inout) | :: | x(ldx,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldx | |||
| real(kind=dp), | intent(out) | :: | ferr(*) | |||
| real(kind=dp), | intent(out) | :: | berr(*) | |||
| real(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | iwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
SSYRFS improves the computed solution to a system of linear equations when the coefficient matrix is symmetric indefinite, and provides error bounds and backward error estimates for the solution.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| real(kind=sp), | intent(in) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=sp), | intent(in) | :: | af(ldaf,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldaf | |||
| integer(kind=ilp), | intent(in) | :: | ipiv(*) | |||
| real(kind=sp), | intent(in) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| real(kind=sp), | intent(inout) | :: | x(ldx,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldx | |||
| real(kind=sp), | intent(out) | :: | ferr(*) | |||
| real(kind=sp), | intent(out) | :: | berr(*) | |||
| real(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | iwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
ZSYRFS improves the computed solution to a system of linear equations when the coefficient matrix is symmetric indefinite, and provides error bounds and backward error estimates for the solution.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| complex(kind=dp), | intent(in) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=dp), | intent(in) | :: | af(ldaf,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldaf | |||
| integer(kind=ilp), | intent(in) | :: | ipiv(*) | |||
| complex(kind=dp), | intent(in) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| complex(kind=dp), | intent(inout) | :: | x(ldx,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldx | |||
| real(kind=dp), | intent(out) | :: | ferr(*) | |||
| real(kind=dp), | intent(out) | :: | berr(*) | |||
| complex(kind=dp), | intent(out) | :: | work(*) | |||
| real(kind=dp), | intent(out) | :: | rwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
SYSV computes the solution to a complex system of linear equations A * X = B, where A is an N-by-N symmetric matrix and X and B are N-by-NRHS matrices. The diagonal pivoting method is used to factor A as A = U * D * UT, if UPLO = 'U', or A = L * D * LT, if UPLO = 'L', where U (or L) is a product of permutation and unit upper (lower) triangular matrices, and D is symmetric and block diagonal with 1-by-1 and 2-by-2 diagonal blocks. The factored form of A is then used to solve the system of equations A * X = B.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| complex(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| integer(kind=ilp), | intent(out) | :: | ipiv(*) | |||
| complex(kind=sp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| complex(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| real(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| integer(kind=ilp), | intent(out) | :: | ipiv(*) | |||
| real(kind=dp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| real(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| real(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| integer(kind=ilp), | intent(out) | :: | ipiv(*) | |||
| real(kind=sp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| real(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| complex(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| integer(kind=ilp), | intent(out) | :: | ipiv(*) | |||
| complex(kind=dp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| complex(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
CSYSV computes the solution to a complex system of linear equations A * X = B, where A is an N-by-N symmetric matrix and X and B are N-by-NRHS matrices. The diagonal pivoting method is used to factor A as A = U * D * UT, if UPLO = 'U', or A = L * D * LT, if UPLO = 'L', where U (or L) is a product of permutation and unit upper (lower) triangular matrices, and D is symmetric and block diagonal with 1-by-1 and 2-by-2 diagonal blocks. The factored form of A is then used to solve the system of equations A * X = B.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| complex(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| integer(kind=ilp), | intent(out) | :: | ipiv(*) | |||
| complex(kind=sp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| complex(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
DSYSV computes the solution to a real system of linear equations A * X = B, where A is an N-by-N symmetric matrix and X and B are N-by-NRHS matrices. The diagonal pivoting method is used to factor A as A = U * D * UT, if UPLO = 'U', or A = L * D * LT, if UPLO = 'L', where U (or L) is a product of permutation and unit upper (lower) triangular matrices, and D is symmetric and block diagonal with 1-by-1 and 2-by-2 diagonal blocks. The factored form of A is then used to solve the system of equations A * X = B.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| real(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| integer(kind=ilp), | intent(out) | :: | ipiv(*) | |||
| real(kind=dp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| real(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
SSYSV computes the solution to a real system of linear equations A * X = B, where A is an N-by-N symmetric matrix and X and B are N-by-NRHS matrices. The diagonal pivoting method is used to factor A as A = U * D * UT, if UPLO = 'U', or A = L * D * LT, if UPLO = 'L', where U (or L) is a product of permutation and unit upper (lower) triangular matrices, and D is symmetric and block diagonal with 1-by-1 and 2-by-2 diagonal blocks. The factored form of A is then used to solve the system of equations A * X = B.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| real(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| integer(kind=ilp), | intent(out) | :: | ipiv(*) | |||
| real(kind=sp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| real(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
ZSYSV computes the solution to a complex system of linear equations A * X = B, where A is an N-by-N symmetric matrix and X and B are N-by-NRHS matrices. The diagonal pivoting method is used to factor A as A = U * D * UT, if UPLO = 'U', or A = L * D * LT, if UPLO = 'L', where U (or L) is a product of permutation and unit upper (lower) triangular matrices, and D is symmetric and block diagonal with 1-by-1 and 2-by-2 diagonal blocks. The factored form of A is then used to solve the system of equations A * X = B.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| complex(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| integer(kind=ilp), | intent(out) | :: | ipiv(*) | |||
| complex(kind=dp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| complex(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
CSYSV computes the solution to a complex system of linear equations A * X = B, where A is an N-by-N symmetric matrix and X and B are N-by-NRHS matrices. Aasen's algorithm is used to factor A as A = UT * T * U, if UPLO = 'U', or A = L * T * LT, if UPLO = 'L', where U (or L) is a product of permutation and unit upper (lower) triangular matrices, and T is symmetric tridiagonal. The factored form of A is then used to solve the system of equations A * X = B.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| complex(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| integer(kind=ilp), | intent(out) | :: | ipiv(*) | |||
| complex(kind=sp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| complex(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| real(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| integer(kind=ilp), | intent(out) | :: | ipiv(*) | |||
| real(kind=dp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| real(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| real(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| integer(kind=ilp), | intent(out) | :: | ipiv(*) | |||
| real(kind=sp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| real(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| complex(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| integer(kind=ilp), | intent(out) | :: | ipiv(*) | |||
| complex(kind=dp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| complex(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
CSYSV computes the solution to a complex system of linear equations A * X = B, where A is an N-by-N symmetric matrix and X and B are N-by-NRHS matrices. Aasen's algorithm is used to factor A as A = UT * T * U, if UPLO = 'U', or A = L * T * LT, if UPLO = 'L', where U (or L) is a product of permutation and unit upper (lower) triangular matrices, and T is symmetric tridiagonal. The factored form of A is then used to solve the system of equations A * X = B.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| complex(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| integer(kind=ilp), | intent(out) | :: | ipiv(*) | |||
| complex(kind=sp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| complex(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
DSYSV computes the solution to a real system of linear equations A * X = B, where A is an N-by-N symmetric matrix and X and B are N-by-NRHS matrices. Aasen's algorithm is used to factor A as A = UT * T * U, if UPLO = 'U', or A = L * T * LT, if UPLO = 'L', where U (or L) is a product of permutation and unit upper (lower) triangular matrices, and T is symmetric tridiagonal. The factored form of A is then used to solve the system of equations A * X = B.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| real(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| integer(kind=ilp), | intent(out) | :: | ipiv(*) | |||
| real(kind=dp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| real(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
SSYSV computes the solution to a real system of linear equations A * X = B, where A is an N-by-N symmetric matrix and X and B are N-by-NRHS matrices. Aasen's algorithm is used to factor A as A = UT * T * U, if UPLO = 'U', or A = L * T * LT, if UPLO = 'L', where U (or L) is a product of permutation and unit upper (lower) triangular matrices, and T is symmetric tridiagonal. The factored form of A is then used to solve the system of equations A * X = B.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| real(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| integer(kind=ilp), | intent(out) | :: | ipiv(*) | |||
| real(kind=sp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| real(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
ZSYSV computes the solution to a complex system of linear equations A * X = B, where A is an N-by-N symmetric matrix and X and B are N-by-NRHS matrices. Aasen's algorithm is used to factor A as A = UT * T * U, if UPLO = 'U', or A = L * T * LT, if UPLO = 'L', where U (or L) is a product of permutation and unit upper (lower) triangular matrices, and T is symmetric tridiagonal. The factored form of A is then used to solve the system of equations A * X = B.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| complex(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| integer(kind=ilp), | intent(out) | :: | ipiv(*) | |||
| complex(kind=dp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| complex(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
SYSV_RK computes the solution to a complex system of linear equations A * X = B, where A is an N-by-N symmetric matrix and X and B are N-by-NRHS matrices. The bounded Bunch-Kaufman (rook) diagonal pivoting method is used to factor A as A = PUD(UT)(PT), if UPLO = 'U', or A = PLD*(LT)(PT), if UPLO = 'L', where U (or L) is unit upper (or lower) triangular matrix, UT (or LT) is the transpose of U (or L), P is a permutation matrix, P*T is the transpose of P, and D is symmetric and block diagonal with 1-by-1 and 2-by-2 diagonal blocks. CSYTRF_RK is called to compute the factorization of a complex symmetric matrix. The factored form of A is then used to solve the system of equations A * X = B by calling BLAS3 routine CSYTRS_3.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| complex(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=sp), | intent(out) | :: | e(*) | |||
| integer(kind=ilp), | intent(out) | :: | ipiv(*) | |||
| complex(kind=sp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| complex(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| real(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=dp), | intent(out) | :: | e(*) | |||
| integer(kind=ilp), | intent(out) | :: | ipiv(*) | |||
| real(kind=dp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| real(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| real(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=sp), | intent(out) | :: | e(*) | |||
| integer(kind=ilp), | intent(out) | :: | ipiv(*) | |||
| real(kind=sp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| real(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| complex(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=dp), | intent(out) | :: | e(*) | |||
| integer(kind=ilp), | intent(out) | :: | ipiv(*) | |||
| complex(kind=dp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| complex(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
CSYSV_RK computes the solution to a complex system of linear equations A * X = B, where A is an N-by-N symmetric matrix and X and B are N-by-NRHS matrices. The bounded Bunch-Kaufman (rook) diagonal pivoting method is used to factor A as A = PUD(UT)(PT), if UPLO = 'U', or A = PLD*(LT)(PT), if UPLO = 'L', where U (or L) is unit upper (or lower) triangular matrix, UT (or LT) is the transpose of U (or L), P is a permutation matrix, P*T is the transpose of P, and D is symmetric and block diagonal with 1-by-1 and 2-by-2 diagonal blocks. CSYTRF_RK is called to compute the factorization of a complex symmetric matrix. The factored form of A is then used to solve the system of equations A * X = B by calling BLAS3 routine CSYTRS_3.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| complex(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=sp), | intent(out) | :: | e(*) | |||
| integer(kind=ilp), | intent(out) | :: | ipiv(*) | |||
| complex(kind=sp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| complex(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
DSYSV_RK computes the solution to a real system of linear equations A * X = B, where A is an N-by-N symmetric matrix and X and B are N-by-NRHS matrices. The bounded Bunch-Kaufman (rook) diagonal pivoting method is used to factor A as A = PUD(UT)(PT), if UPLO = 'U', or A = PLD*(LT)(PT), if UPLO = 'L', where U (or L) is unit upper (or lower) triangular matrix, UT (or LT) is the transpose of U (or L), P is a permutation matrix, P*T is the transpose of P, and D is symmetric and block diagonal with 1-by-1 and 2-by-2 diagonal blocks. DSYTRF_RK is called to compute the factorization of a real symmetric matrix. The factored form of A is then used to solve the system of equations A * X = B by calling BLAS3 routine DSYTRS_3.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| real(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=dp), | intent(out) | :: | e(*) | |||
| integer(kind=ilp), | intent(out) | :: | ipiv(*) | |||
| real(kind=dp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| real(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
SSYSV_RK computes the solution to a real system of linear equations A * X = B, where A is an N-by-N symmetric matrix and X and B are N-by-NRHS matrices. The bounded Bunch-Kaufman (rook) diagonal pivoting method is used to factor A as A = PUD(UT)(PT), if UPLO = 'U', or A = PLD*(LT)(PT), if UPLO = 'L', where U (or L) is unit upper (or lower) triangular matrix, UT (or LT) is the transpose of U (or L), P is a permutation matrix, P*T is the transpose of P, and D is symmetric and block diagonal with 1-by-1 and 2-by-2 diagonal blocks. SSYTRF_RK is called to compute the factorization of a real symmetric matrix. The factored form of A is then used to solve the system of equations A * X = B by calling BLAS3 routine SSYTRS_3.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| real(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=sp), | intent(out) | :: | e(*) | |||
| integer(kind=ilp), | intent(out) | :: | ipiv(*) | |||
| real(kind=sp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| real(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
ZSYSV_RK computes the solution to a complex system of linear equations A * X = B, where A is an N-by-N symmetric matrix and X and B are N-by-NRHS matrices. The bounded Bunch-Kaufman (rook) diagonal pivoting method is used to factor A as A = PUD(UT)(PT), if UPLO = 'U', or A = PLD*(LT)(PT), if UPLO = 'L', where U (or L) is unit upper (or lower) triangular matrix, UT (or LT) is the transpose of U (or L), P is a permutation matrix, P*T is the transpose of P, and D is symmetric and block diagonal with 1-by-1 and 2-by-2 diagonal blocks. ZSYTRF_RK is called to compute the factorization of a complex symmetric matrix. The factored form of A is then used to solve the system of equations A * X = B by calling BLAS3 routine ZSYTRS_3.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| complex(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=dp), | intent(out) | :: | e(*) | |||
| integer(kind=ilp), | intent(out) | :: | ipiv(*) | |||
| complex(kind=dp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| complex(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
SYSV_ROOK computes the solution to a complex system of linear equations A * X = B, where A is an N-by-N symmetric matrix and X and B are N-by-NRHS matrices. The diagonal pivoting method is used to factor A as A = U * D * UT, if UPLO = 'U', or A = L * D * LT, if UPLO = 'L', where U (or L) is a product of permutation and unit upper (lower) triangular matrices, and D is symmetric and block diagonal with 1-by-1 and 2-by-2 diagonal blocks. CSYTRF_ROOK is called to compute the factorization of a complex symmetric matrix A using the bounded Bunch-Kaufman ("rook") diagonal pivoting method. The factored form of A is then used to solve the system of equations A * X = B by calling CSYTRS_ROOK.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| complex(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| integer(kind=ilp), | intent(out) | :: | ipiv(*) | |||
| complex(kind=sp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| complex(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| real(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| integer(kind=ilp), | intent(out) | :: | ipiv(*) | |||
| real(kind=dp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| real(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| real(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| integer(kind=ilp), | intent(out) | :: | ipiv(*) | |||
| real(kind=sp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| real(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| complex(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| integer(kind=ilp), | intent(out) | :: | ipiv(*) | |||
| complex(kind=dp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| complex(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
CSYSV_ROOK computes the solution to a complex system of linear equations A * X = B, where A is an N-by-N symmetric matrix and X and B are N-by-NRHS matrices. The diagonal pivoting method is used to factor A as A = U * D * UT, if UPLO = 'U', or A = L * D * LT, if UPLO = 'L', where U (or L) is a product of permutation and unit upper (lower) triangular matrices, and D is symmetric and block diagonal with 1-by-1 and 2-by-2 diagonal blocks. CSYTRF_ROOK is called to compute the factorization of a complex symmetric matrix A using the bounded Bunch-Kaufman ("rook") diagonal pivoting method. The factored form of A is then used to solve the system of equations A * X = B by calling CSYTRS_ROOK.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| complex(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| integer(kind=ilp), | intent(out) | :: | ipiv(*) | |||
| complex(kind=sp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| complex(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
DSYSV_ROOK computes the solution to a real system of linear equations A * X = B, where A is an N-by-N symmetric matrix and X and B are N-by-NRHS matrices. The diagonal pivoting method is used to factor A as A = U * D * UT, if UPLO = 'U', or A = L * D * LT, if UPLO = 'L', where U (or L) is a product of permutation and unit upper (lower) triangular matrices, and D is symmetric and block diagonal with 1-by-1 and 2-by-2 diagonal blocks. DSYTRF_ROOK is called to compute the factorization of a real symmetric matrix A using the bounded Bunch-Kaufman ("rook") diagonal pivoting method. The factored form of A is then used to solve the system of equations A * X = B by calling DSYTRS_ROOK.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| real(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| integer(kind=ilp), | intent(out) | :: | ipiv(*) | |||
| real(kind=dp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| real(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
SSYSV_ROOK computes the solution to a real system of linear equations A * X = B, where A is an N-by-N symmetric matrix and X and B are N-by-NRHS matrices. The diagonal pivoting method is used to factor A as A = U * D * UT, if UPLO = 'U', or A = L * D * LT, if UPLO = 'L', where U (or L) is a product of permutation and unit upper (lower) triangular matrices, and D is symmetric and block diagonal with 1-by-1 and 2-by-2 diagonal blocks. SSYTRF_ROOK is called to compute the factorization of a real symmetric matrix A using the bounded Bunch-Kaufman ("rook") diagonal pivoting method. The factored form of A is then used to solve the system of equations A * X = B by calling SSYTRS_ROOK.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| real(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| integer(kind=ilp), | intent(out) | :: | ipiv(*) | |||
| real(kind=sp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| real(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
ZSYSV_ROOK computes the solution to a complex system of linear equations A * X = B, where A is an N-by-N symmetric matrix and X and B are N-by-NRHS matrices. The diagonal pivoting method is used to factor A as A = U * D * UT, if UPLO = 'U', or A = L * D * LT, if UPLO = 'L', where U (or L) is a product of permutation and unit upper (lower) triangular matrices, and D is symmetric and block diagonal with 1-by-1 and 2-by-2 diagonal blocks. ZSYTRF_ROOK is called to compute the factorization of a complex symmetric matrix A using the bounded Bunch-Kaufman ("rook") diagonal pivoting method. The factored form of A is then used to solve the system of equations A * X = B by calling ZSYTRS_ROOK.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| complex(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| integer(kind=ilp), | intent(out) | :: | ipiv(*) | |||
| complex(kind=dp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| complex(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
SYSWAPR applies an elementary permutation on the rows and the columns of a symmetric matrix.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=sp), | intent(inout) | :: | a(lda,n) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| integer(kind=ilp), | intent(in) | :: | i1 | |||
| integer(kind=ilp), | intent(in) | :: | i2 |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=dp), | intent(inout) | :: | a(lda,n) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| integer(kind=ilp), | intent(in) | :: | i1 | |||
| integer(kind=ilp), | intent(in) | :: | i2 |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=sp), | intent(inout) | :: | a(lda,n) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| integer(kind=ilp), | intent(in) | :: | i1 | |||
| integer(kind=ilp), | intent(in) | :: | i2 |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=dp), | intent(inout) | :: | a(lda,n) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| integer(kind=ilp), | intent(in) | :: | i1 | |||
| integer(kind=ilp), | intent(in) | :: | i2 |
CSYSWAPR applies an elementary permutation on the rows and the columns of a symmetric matrix.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=sp), | intent(inout) | :: | a(lda,n) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| integer(kind=ilp), | intent(in) | :: | i1 | |||
| integer(kind=ilp), | intent(in) | :: | i2 |
DSYSWAPR applies an elementary permutation on the rows and the columns of a symmetric matrix.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=dp), | intent(inout) | :: | a(lda,n) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| integer(kind=ilp), | intent(in) | :: | i1 | |||
| integer(kind=ilp), | intent(in) | :: | i2 |
SSYSWAPR applies an elementary permutation on the rows and the columns of a symmetric matrix.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=sp), | intent(inout) | :: | a(lda,n) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| integer(kind=ilp), | intent(in) | :: | i1 | |||
| integer(kind=ilp), | intent(in) | :: | i2 |
ZSYSWAPR applies an elementary permutation on the rows and the columns of a symmetric matrix.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=dp), | intent(inout) | :: | a(lda,n) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| integer(kind=ilp), | intent(in) | :: | i1 | |||
| integer(kind=ilp), | intent(in) | :: | i2 |
SYTF2_RK computes the factorization of a complex symmetric matrix A using the bounded Bunch-Kaufman (rook) diagonal pivoting method: A = PUD(UT)(PT) or A = PLD*(LT)(PT), where U (or L) is unit upper (or lower) triangular matrix, UT (or LT) is the transpose of U (or L), P is a permutation matrix, P*T is the transpose of P, and D is symmetric and block diagonal with 1-by-1 and 2-by-2 diagonal blocks. This is the unblocked version of the algorithm, calling Level 2 BLAS. For more information see Further Details section.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=sp), | intent(out) | :: | e(*) | |||
| integer(kind=ilp), | intent(out) | :: | ipiv(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=dp), | intent(out) | :: | e(*) | |||
| integer(kind=ilp), | intent(out) | :: | ipiv(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=sp), | intent(out) | :: | e(*) | |||
| integer(kind=ilp), | intent(out) | :: | ipiv(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=dp), | intent(out) | :: | e(*) | |||
| integer(kind=ilp), | intent(out) | :: | ipiv(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
CSYTF2_RK computes the factorization of a complex symmetric matrix A using the bounded Bunch-Kaufman (rook) diagonal pivoting method: A = PUD(UT)(PT) or A = PLD*(LT)(PT), where U (or L) is unit upper (or lower) triangular matrix, UT (or LT) is the transpose of U (or L), P is a permutation matrix, P*T is the transpose of P, and D is symmetric and block diagonal with 1-by-1 and 2-by-2 diagonal blocks. This is the unblocked version of the algorithm, calling Level 2 BLAS. For more information see Further Details section.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=sp), | intent(out) | :: | e(*) | |||
| integer(kind=ilp), | intent(out) | :: | ipiv(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
DSYTF2_RK computes the factorization of a real symmetric matrix A using the bounded Bunch-Kaufman (rook) diagonal pivoting method: A = PUD(UT)(PT) or A = PLD*(LT)(PT), where U (or L) is unit upper (or lower) triangular matrix, UT (or LT) is the transpose of U (or L), P is a permutation matrix, P*T is the transpose of P, and D is symmetric and block diagonal with 1-by-1 and 2-by-2 diagonal blocks. This is the unblocked version of the algorithm, calling Level 2 BLAS. For more information see Further Details section.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=dp), | intent(out) | :: | e(*) | |||
| integer(kind=ilp), | intent(out) | :: | ipiv(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
SSYTF2_RK computes the factorization of a real symmetric matrix A using the bounded Bunch-Kaufman (rook) diagonal pivoting method: A = PUD(UT)(PT) or A = PLD*(LT)(PT), where U (or L) is unit upper (or lower) triangular matrix, UT (or LT) is the transpose of U (or L), P is a permutation matrix, P*T is the transpose of P, and D is symmetric and block diagonal with 1-by-1 and 2-by-2 diagonal blocks. This is the unblocked version of the algorithm, calling Level 2 BLAS. For more information see Further Details section.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=sp), | intent(out) | :: | e(*) | |||
| integer(kind=ilp), | intent(out) | :: | ipiv(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
ZSYTF2_RK computes the factorization of a complex symmetric matrix A using the bounded Bunch-Kaufman (rook) diagonal pivoting method: A = PUD(UT)(PT) or A = PLD*(LT)(PT), where U (or L) is unit upper (or lower) triangular matrix, UT (or LT) is the transpose of U (or L), P is a permutation matrix, P*T is the transpose of P, and D is symmetric and block diagonal with 1-by-1 and 2-by-2 diagonal blocks. This is the unblocked version of the algorithm, calling Level 2 BLAS. For more information see Further Details section.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=dp), | intent(out) | :: | e(*) | |||
| integer(kind=ilp), | intent(out) | :: | ipiv(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
SYTF2_ROOK computes the factorization of a complex symmetric matrix A using the bounded Bunch-Kaufman ("rook") diagonal pivoting method: A = UDUT or A = LDLT where U (or L) is a product of permutation and unit upper (lower) triangular matrices, U**T is the transpose of U, and D is symmetric and block diagonal with 1-by-1 and 2-by-2 diagonal blocks. This is the unblocked version of the algorithm, calling Level 2 BLAS.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| integer(kind=ilp), | intent(out) | :: | ipiv(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| integer(kind=ilp), | intent(out) | :: | ipiv(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| integer(kind=ilp), | intent(out) | :: | ipiv(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| integer(kind=ilp), | intent(out) | :: | ipiv(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
CSYTF2_ROOK computes the factorization of a complex symmetric matrix A using the bounded Bunch-Kaufman ("rook") diagonal pivoting method: A = UDUT or A = LDLT where U (or L) is a product of permutation and unit upper (lower) triangular matrices, U**T is the transpose of U, and D is symmetric and block diagonal with 1-by-1 and 2-by-2 diagonal blocks. This is the unblocked version of the algorithm, calling Level 2 BLAS.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| integer(kind=ilp), | intent(out) | :: | ipiv(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
DSYTF2_ROOK computes the factorization of a real symmetric matrix A using the bounded Bunch-Kaufman ("rook") diagonal pivoting method: A = UDUT or A = LDLT where U (or L) is a product of permutation and unit upper (lower) triangular matrices, U**T is the transpose of U, and D is symmetric and block diagonal with 1-by-1 and 2-by-2 diagonal blocks. This is the unblocked version of the algorithm, calling Level 2 BLAS.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| integer(kind=ilp), | intent(out) | :: | ipiv(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
SSYTF2_ROOK computes the factorization of a real symmetric matrix A using the bounded Bunch-Kaufman ("rook") diagonal pivoting method: A = UDUT or A = LDLT where U (or L) is a product of permutation and unit upper (lower) triangular matrices, U**T is the transpose of U, and D is symmetric and block diagonal with 1-by-1 and 2-by-2 diagonal blocks. This is the unblocked version of the algorithm, calling Level 2 BLAS.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| integer(kind=ilp), | intent(out) | :: | ipiv(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
ZSYTF2_ROOK computes the factorization of a complex symmetric matrix A using the bounded Bunch-Kaufman ("rook") diagonal pivoting method: A = UDUT or A = LDLT where U (or L) is a product of permutation and unit upper (lower) triangular matrices, U**T is the transpose of U, and D is symmetric and block diagonal with 1-by-1 and 2-by-2 diagonal blocks. This is the unblocked version of the algorithm, calling Level 2 BLAS.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| integer(kind=ilp), | intent(out) | :: | ipiv(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
SYTRD reduces a real symmetric matrix A to real symmetric tridiagonal form T by an orthogonal similarity transformation: Q**T * A * Q = T.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=dp), | intent(out) | :: | d(*) | |||
| real(kind=dp), | intent(out) | :: | e(*) | |||
| real(kind=dp), | intent(out) | :: | tau(*) | |||
| real(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=sp), | intent(out) | :: | d(*) | |||
| real(kind=sp), | intent(out) | :: | e(*) | |||
| real(kind=sp), | intent(out) | :: | tau(*) | |||
| real(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
DSYTRD reduces a real symmetric matrix A to real symmetric tridiagonal form T by an orthogonal similarity transformation: Q**T * A * Q = T.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=dp), | intent(out) | :: | d(*) | |||
| real(kind=dp), | intent(out) | :: | e(*) | |||
| real(kind=dp), | intent(out) | :: | tau(*) | |||
| real(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
SSYTRD reduces a real symmetric matrix A to real symmetric tridiagonal form T by an orthogonal similarity transformation: Q**T * A * Q = T.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=sp), | intent(out) | :: | d(*) | |||
| real(kind=sp), | intent(out) | :: | e(*) | |||
| real(kind=sp), | intent(out) | :: | tau(*) | |||
| real(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
SYTRD_SB2ST reduces a real symmetric band matrix A to real symmetric tridiagonal form T by a orthogonal similarity transformation: Q**T * A * Q = T.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | stage1 | |||
| character, | intent(in) | :: | vect | |||
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | kd | |||
| real(kind=dp), | intent(inout) | :: | ab(ldab,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldab | |||
| real(kind=dp), | intent(out) | :: | d(*) | |||
| real(kind=dp), | intent(out) | :: | e(*) | |||
| real(kind=dp), | intent(out) | :: | hous(*) | |||
| integer(kind=ilp), | intent(in) | :: | lhous | |||
| real(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | stage1 | |||
| character, | intent(in) | :: | vect | |||
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | kd | |||
| real(kind=sp), | intent(inout) | :: | ab(ldab,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldab | |||
| real(kind=sp), | intent(out) | :: | d(*) | |||
| real(kind=sp), | intent(out) | :: | e(*) | |||
| real(kind=sp), | intent(out) | :: | hous(*) | |||
| integer(kind=ilp), | intent(in) | :: | lhous | |||
| real(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
DSYTRD_SB2ST reduces a real symmetric band matrix A to real symmetric tridiagonal form T by a orthogonal similarity transformation: Q**T * A * Q = T.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | stage1 | |||
| character, | intent(in) | :: | vect | |||
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | kd | |||
| real(kind=dp), | intent(inout) | :: | ab(ldab,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldab | |||
| real(kind=dp), | intent(out) | :: | d(*) | |||
| real(kind=dp), | intent(out) | :: | e(*) | |||
| real(kind=dp), | intent(out) | :: | hous(*) | |||
| integer(kind=ilp), | intent(in) | :: | lhous | |||
| real(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
SSYTRD_SB2ST reduces a real symmetric band matrix A to real symmetric tridiagonal form T by a orthogonal similarity transformation: Q**T * A * Q = T.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | stage1 | |||
| character, | intent(in) | :: | vect | |||
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | kd | |||
| real(kind=sp), | intent(inout) | :: | ab(ldab,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldab | |||
| real(kind=sp), | intent(out) | :: | d(*) | |||
| real(kind=sp), | intent(out) | :: | e(*) | |||
| real(kind=sp), | intent(out) | :: | hous(*) | |||
| integer(kind=ilp), | intent(in) | :: | lhous | |||
| real(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
SYTRD_SY2SB reduces a real symmetric matrix A to real symmetric band-diagonal form AB by a orthogonal similarity transformation: Q**T * A * Q = AB.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | kd | |||
| real(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=dp), | intent(out) | :: | ab(ldab,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldab | |||
| real(kind=dp), | intent(out) | :: | tau(*) | |||
| real(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | kd | |||
| real(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=sp), | intent(out) | :: | ab(ldab,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldab | |||
| real(kind=sp), | intent(out) | :: | tau(*) | |||
| real(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
DSYTRD_SY2SB reduces a real symmetric matrix A to real symmetric band-diagonal form AB by a orthogonal similarity transformation: Q**T * A * Q = AB.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | kd | |||
| real(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=dp), | intent(out) | :: | ab(ldab,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldab | |||
| real(kind=dp), | intent(out) | :: | tau(*) | |||
| real(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
SSYTRD_SY2SB reduces a real symmetric matrix A to real symmetric band-diagonal form AB by a orthogonal similarity transformation: Q**T * A * Q = AB.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | kd | |||
| real(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=sp), | intent(out) | :: | ab(ldab,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldab | |||
| real(kind=sp), | intent(out) | :: | tau(*) | |||
| real(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
SYTRF computes the factorization of a complex symmetric matrix A using the Bunch-Kaufman diagonal pivoting method. The form of the factorization is A = UDUT or A = LDLT where U (or L) is a product of permutation and unit upper (lower) triangular matrices, and D is symmetric and block diagonal with 1-by-1 and 2-by-2 diagonal blocks. This is the blocked version of the algorithm, calling Level 3 BLAS.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| integer(kind=ilp), | intent(out) | :: | ipiv(*) | |||
| complex(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| integer(kind=ilp), | intent(out) | :: | ipiv(*) | |||
| real(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| integer(kind=ilp), | intent(out) | :: | ipiv(*) | |||
| real(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| integer(kind=ilp), | intent(out) | :: | ipiv(*) | |||
| complex(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
CSYTRF computes the factorization of a complex symmetric matrix A using the Bunch-Kaufman diagonal pivoting method. The form of the factorization is A = UDUT or A = LDLT where U (or L) is a product of permutation and unit upper (lower) triangular matrices, and D is symmetric and block diagonal with 1-by-1 and 2-by-2 diagonal blocks. This is the blocked version of the algorithm, calling Level 3 BLAS.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| integer(kind=ilp), | intent(out) | :: | ipiv(*) | |||
| complex(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
DSYTRF computes the factorization of a real symmetric matrix A using the Bunch-Kaufman diagonal pivoting method. The form of the factorization is A = UTDU or A = LDLT where U (or L) is a product of permutation and unit upper (lower) triangular matrices, and D is symmetric and block diagonal with 1-by-1 and 2-by-2 diagonal blocks. This is the blocked version of the algorithm, calling Level 3 BLAS.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| integer(kind=ilp), | intent(out) | :: | ipiv(*) | |||
| real(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
SSYTRF computes the factorization of a real symmetric matrix A using the Bunch-Kaufman diagonal pivoting method. The form of the factorization is A = UTDU or A = LDLT where U (or L) is a product of permutation and unit upper (lower) triangular matrices, and D is symmetric and block diagonal with 1-by-1 and 2-by-2 diagonal blocks. This is the blocked version of the algorithm, calling Level 3 BLAS.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| integer(kind=ilp), | intent(out) | :: | ipiv(*) | |||
| real(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
ZSYTRF computes the factorization of a complex symmetric matrix A using the Bunch-Kaufman diagonal pivoting method. The form of the factorization is A = UDUT or A = LDLT where U (or L) is a product of permutation and unit upper (lower) triangular matrices, and D is symmetric and block diagonal with 1-by-1 and 2-by-2 diagonal blocks. This is the blocked version of the algorithm, calling Level 3 BLAS.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| integer(kind=ilp), | intent(out) | :: | ipiv(*) | |||
| complex(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
SYTRF_AA computes the factorization of a complex symmetric matrix A using the Aasen's algorithm. The form of the factorization is A = UTTU or A = LTLT where U (or L) is a product of permutation and unit upper (lower) triangular matrices, and T is a complex symmetric tridiagonal matrix. This is the blocked version of the algorithm, calling Level 3 BLAS.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| integer(kind=ilp), | intent(out) | :: | ipiv(*) | |||
| complex(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| integer(kind=ilp), | intent(out) | :: | ipiv(*) | |||
| real(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| integer(kind=ilp), | intent(out) | :: | ipiv(*) | |||
| real(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| integer(kind=ilp), | intent(out) | :: | ipiv(*) | |||
| complex(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
CSYTRF_AA computes the factorization of a complex symmetric matrix A using the Aasen's algorithm. The form of the factorization is A = UTTU or A = LTLT where U (or L) is a product of permutation and unit upper (lower) triangular matrices, and T is a complex symmetric tridiagonal matrix. This is the blocked version of the algorithm, calling Level 3 BLAS.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| integer(kind=ilp), | intent(out) | :: | ipiv(*) | |||
| complex(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
DSYTRF_AA computes the factorization of a real symmetric matrix A using the Aasen's algorithm. The form of the factorization is A = UTTU or A = LTLT where U (or L) is a product of permutation and unit upper (lower) triangular matrices, and T is a symmetric tridiagonal matrix. This is the blocked version of the algorithm, calling Level 3 BLAS.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| integer(kind=ilp), | intent(out) | :: | ipiv(*) | |||
| real(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
SSYTRF_AA computes the factorization of a real symmetric matrix A using the Aasen's algorithm. The form of the factorization is A = UTTU or A = LTLT where U (or L) is a product of permutation and unit upper (lower) triangular matrices, and T is a symmetric tridiagonal matrix. This is the blocked version of the algorithm, calling Level 3 BLAS.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| integer(kind=ilp), | intent(out) | :: | ipiv(*) | |||
| real(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
ZSYTRF_AA computes the factorization of a complex symmetric matrix A using the Aasen's algorithm. The form of the factorization is A = UTTU or A = LTLT where U (or L) is a product of permutation and unit upper (lower) triangular matrices, and T is a complex symmetric tridiagonal matrix. This is the blocked version of the algorithm, calling Level 3 BLAS.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| integer(kind=ilp), | intent(out) | :: | ipiv(*) | |||
| complex(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
SYTRF_RK computes the factorization of a complex symmetric matrix A using the bounded Bunch-Kaufman (rook) diagonal pivoting method: A = PUD(UT)(PT) or A = PLD*(LT)(PT), where U (or L) is unit upper (or lower) triangular matrix, UT (or LT) is the transpose of U (or L), P is a permutation matrix, P*T is the transpose of P, and D is symmetric and block diagonal with 1-by-1 and 2-by-2 diagonal blocks. This is the blocked version of the algorithm, calling Level 3 BLAS. For more information see Further Details section.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=sp), | intent(out) | :: | e(*) | |||
| integer(kind=ilp), | intent(out) | :: | ipiv(*) | |||
| complex(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=dp), | intent(out) | :: | e(*) | |||
| integer(kind=ilp), | intent(out) | :: | ipiv(*) | |||
| real(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=sp), | intent(out) | :: | e(*) | |||
| integer(kind=ilp), | intent(out) | :: | ipiv(*) | |||
| real(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=dp), | intent(out) | :: | e(*) | |||
| integer(kind=ilp), | intent(out) | :: | ipiv(*) | |||
| complex(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
CSYTRF_RK computes the factorization of a complex symmetric matrix A using the bounded Bunch-Kaufman (rook) diagonal pivoting method: A = PUD(UT)(PT) or A = PLD*(LT)(PT), where U (or L) is unit upper (or lower) triangular matrix, UT (or LT) is the transpose of U (or L), P is a permutation matrix, P*T is the transpose of P, and D is symmetric and block diagonal with 1-by-1 and 2-by-2 diagonal blocks. This is the blocked version of the algorithm, calling Level 3 BLAS. For more information see Further Details section.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=sp), | intent(out) | :: | e(*) | |||
| integer(kind=ilp), | intent(out) | :: | ipiv(*) | |||
| complex(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
DSYTRF_RK computes the factorization of a real symmetric matrix A using the bounded Bunch-Kaufman (rook) diagonal pivoting method: A = PUD(UT)(PT) or A = PLD*(LT)(PT), where U (or L) is unit upper (or lower) triangular matrix, UT (or LT) is the transpose of U (or L), P is a permutation matrix, P*T is the transpose of P, and D is symmetric and block diagonal with 1-by-1 and 2-by-2 diagonal blocks. This is the blocked version of the algorithm, calling Level 3 BLAS. For more information see Further Details section.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=dp), | intent(out) | :: | e(*) | |||
| integer(kind=ilp), | intent(out) | :: | ipiv(*) | |||
| real(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
SSYTRF_RK computes the factorization of a real symmetric matrix A using the bounded Bunch-Kaufman (rook) diagonal pivoting method: A = PUD(UT)(PT) or A = PLD*(LT)(PT), where U (or L) is unit upper (or lower) triangular matrix, UT (or LT) is the transpose of U (or L), P is a permutation matrix, P*T is the transpose of P, and D is symmetric and block diagonal with 1-by-1 and 2-by-2 diagonal blocks. This is the blocked version of the algorithm, calling Level 3 BLAS. For more information see Further Details section.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=sp), | intent(out) | :: | e(*) | |||
| integer(kind=ilp), | intent(out) | :: | ipiv(*) | |||
| real(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
ZSYTRF_RK computes the factorization of a complex symmetric matrix A using the bounded Bunch-Kaufman (rook) diagonal pivoting method: A = PUD(UT)(PT) or A = PLD*(LT)(PT), where U (or L) is unit upper (or lower) triangular matrix, UT (or LT) is the transpose of U (or L), P is a permutation matrix, P*T is the transpose of P, and D is symmetric and block diagonal with 1-by-1 and 2-by-2 diagonal blocks. This is the blocked version of the algorithm, calling Level 3 BLAS. For more information see Further Details section.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=dp), | intent(out) | :: | e(*) | |||
| integer(kind=ilp), | intent(out) | :: | ipiv(*) | |||
| complex(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
SYTRF_ROOK computes the factorization of a complex symmetric matrix A using the bounded Bunch-Kaufman ("rook") diagonal pivoting method. The form of the factorization is A = UDUT or A = LDLT where U (or L) is a product of permutation and unit upper (lower) triangular matrices, and D is symmetric and block diagonal with 1-by-1 and 2-by-2 diagonal blocks. This is the blocked version of the algorithm, calling Level 3 BLAS.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| integer(kind=ilp), | intent(out) | :: | ipiv(*) | |||
| complex(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| integer(kind=ilp), | intent(out) | :: | ipiv(*) | |||
| real(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| integer(kind=ilp), | intent(out) | :: | ipiv(*) | |||
| real(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| integer(kind=ilp), | intent(out) | :: | ipiv(*) | |||
| complex(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
CSYTRF_ROOK computes the factorization of a complex symmetric matrix A using the bounded Bunch-Kaufman ("rook") diagonal pivoting method. The form of the factorization is A = UDUT or A = LDLT where U (or L) is a product of permutation and unit upper (lower) triangular matrices, and D is symmetric and block diagonal with 1-by-1 and 2-by-2 diagonal blocks. This is the blocked version of the algorithm, calling Level 3 BLAS.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| integer(kind=ilp), | intent(out) | :: | ipiv(*) | |||
| complex(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
DSYTRF_ROOK computes the factorization of a real symmetric matrix A using the bounded Bunch-Kaufman ("rook") diagonal pivoting method. The form of the factorization is A = UDUT or A = LDLT where U (or L) is a product of permutation and unit upper (lower) triangular matrices, and D is symmetric and block diagonal with 1-by-1 and 2-by-2 diagonal blocks. This is the blocked version of the algorithm, calling Level 3 BLAS.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| integer(kind=ilp), | intent(out) | :: | ipiv(*) | |||
| real(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
SSYTRF_ROOK computes the factorization of a real symmetric matrix A using the bounded Bunch-Kaufman ("rook") diagonal pivoting method. The form of the factorization is A = UDUT or A = LDLT where U (or L) is a product of permutation and unit upper (lower) triangular matrices, and D is symmetric and block diagonal with 1-by-1 and 2-by-2 diagonal blocks. This is the blocked version of the algorithm, calling Level 3 BLAS.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| integer(kind=ilp), | intent(out) | :: | ipiv(*) | |||
| real(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
ZSYTRF_ROOK computes the factorization of a complex symmetric matrix A using the bounded Bunch-Kaufman ("rook") diagonal pivoting method. The form of the factorization is A = UDUT or A = LDLT where U (or L) is a product of permutation and unit upper (lower) triangular matrices, and D is symmetric and block diagonal with 1-by-1 and 2-by-2 diagonal blocks. This is the blocked version of the algorithm, calling Level 3 BLAS.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| integer(kind=ilp), | intent(out) | :: | ipiv(*) | |||
| complex(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
SYTRI computes the inverse of a complex symmetric indefinite matrix A using the factorization A = UDUT or A = LDLT computed by CSYTRF.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| integer(kind=ilp), | intent(in) | :: | ipiv(*) | |||
| complex(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| integer(kind=ilp), | intent(in) | :: | ipiv(*) | |||
| real(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| integer(kind=ilp), | intent(in) | :: | ipiv(*) | |||
| real(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| integer(kind=ilp), | intent(in) | :: | ipiv(*) | |||
| complex(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
CSYTRI computes the inverse of a complex symmetric indefinite matrix A using the factorization A = UDUT or A = LDLT computed by CSYTRF.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| integer(kind=ilp), | intent(in) | :: | ipiv(*) | |||
| complex(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
DSYTRI computes the inverse of a real symmetric indefinite matrix A using the factorization A = UDUT or A = LDLT computed by DSYTRF.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| integer(kind=ilp), | intent(in) | :: | ipiv(*) | |||
| real(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
SSYTRI computes the inverse of a real symmetric indefinite matrix A using the factorization A = UDUT or A = LDLT computed by SSYTRF.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| integer(kind=ilp), | intent(in) | :: | ipiv(*) | |||
| real(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
ZSYTRI computes the inverse of a complex symmetric indefinite matrix A using the factorization A = UDUT or A = LDLT computed by ZSYTRF.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| integer(kind=ilp), | intent(in) | :: | ipiv(*) | |||
| complex(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
SYTRI_ROOK computes the inverse of a complex symmetric matrix A using the factorization A = UDUT or A = LDLT computed by CSYTRF_ROOK.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| integer(kind=ilp), | intent(in) | :: | ipiv(*) | |||
| complex(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| integer(kind=ilp), | intent(in) | :: | ipiv(*) | |||
| real(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| integer(kind=ilp), | intent(in) | :: | ipiv(*) | |||
| real(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| integer(kind=ilp), | intent(in) | :: | ipiv(*) | |||
| complex(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
CSYTRI_ROOK computes the inverse of a complex symmetric matrix A using the factorization A = UDUT or A = LDLT computed by CSYTRF_ROOK.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| integer(kind=ilp), | intent(in) | :: | ipiv(*) | |||
| complex(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
DSYTRI_ROOK computes the inverse of a real symmetric matrix A using the factorization A = UDUT or A = LDLT computed by DSYTRF_ROOK.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| integer(kind=ilp), | intent(in) | :: | ipiv(*) | |||
| real(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
SSYTRI_ROOK computes the inverse of a real symmetric matrix A using the factorization A = UDUT or A = LDLT computed by SSYTRF_ROOK.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| integer(kind=ilp), | intent(in) | :: | ipiv(*) | |||
| real(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
ZSYTRI_ROOK computes the inverse of a complex symmetric matrix A using the factorization A = UDUT or A = LDLT computed by ZSYTRF_ROOK.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| integer(kind=ilp), | intent(in) | :: | ipiv(*) | |||
| complex(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
SYTRS solves a system of linear equations AX = B with a complex symmetric matrix A using the factorization A = UDUT or A = LDL*T computed by CSYTRF.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| complex(kind=sp), | intent(in) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| integer(kind=ilp), | intent(in) | :: | ipiv(*) | |||
| complex(kind=sp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| real(kind=dp), | intent(in) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| integer(kind=ilp), | intent(in) | :: | ipiv(*) | |||
| real(kind=dp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| real(kind=sp), | intent(in) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| integer(kind=ilp), | intent(in) | :: | ipiv(*) | |||
| real(kind=sp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| complex(kind=dp), | intent(in) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| integer(kind=ilp), | intent(in) | :: | ipiv(*) | |||
| complex(kind=dp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| integer(kind=ilp), | intent(out) | :: | info |
CSYTRS solves a system of linear equations AX = B with a complex symmetric matrix A using the factorization A = UDUT or A = LDL*T computed by CSYTRF.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| complex(kind=sp), | intent(in) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| integer(kind=ilp), | intent(in) | :: | ipiv(*) | |||
| complex(kind=sp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| integer(kind=ilp), | intent(out) | :: | info |
DSYTRS solves a system of linear equations AX = B with a real symmetric matrix A using the factorization A = UDUT or A = LDL*T computed by DSYTRF.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| real(kind=dp), | intent(in) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| integer(kind=ilp), | intent(in) | :: | ipiv(*) | |||
| real(kind=dp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| integer(kind=ilp), | intent(out) | :: | info |
SSYTRS solves a system of linear equations AX = B with a real symmetric matrix A using the factorization A = UDUT or A = LDL*T computed by SSYTRF.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| real(kind=sp), | intent(in) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| integer(kind=ilp), | intent(in) | :: | ipiv(*) | |||
| real(kind=sp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| integer(kind=ilp), | intent(out) | :: | info |
ZSYTRS solves a system of linear equations AX = B with a complex symmetric matrix A using the factorization A = UDUT or A = LDL*T computed by ZSYTRF.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| complex(kind=dp), | intent(in) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| integer(kind=ilp), | intent(in) | :: | ipiv(*) | |||
| complex(kind=dp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| integer(kind=ilp), | intent(out) | :: | info |
SYTRS2 solves a system of linear equations AX = B with a complex symmetric matrix A using the factorization A = UDUT or A = LDL*T computed by CSYTRF and converted by CSYCONV.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| complex(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| integer(kind=ilp), | intent(in) | :: | ipiv(*) | |||
| complex(kind=sp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| complex(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| real(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| integer(kind=ilp), | intent(in) | :: | ipiv(*) | |||
| real(kind=dp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| real(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| real(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| integer(kind=ilp), | intent(in) | :: | ipiv(*) | |||
| real(kind=sp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| real(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| complex(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| integer(kind=ilp), | intent(in) | :: | ipiv(*) | |||
| complex(kind=dp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| complex(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
CSYTRS2 solves a system of linear equations AX = B with a complex symmetric matrix A using the factorization A = UDUT or A = LDL*T computed by CSYTRF and converted by CSYCONV.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| complex(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| integer(kind=ilp), | intent(in) | :: | ipiv(*) | |||
| complex(kind=sp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| complex(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
DSYTRS2 solves a system of linear equations AX = B with a real symmetric matrix A using the factorization A = UDUT or A = LDL*T computed by DSYTRF and converted by DSYCONV.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| real(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| integer(kind=ilp), | intent(in) | :: | ipiv(*) | |||
| real(kind=dp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| real(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
SSYTRS2 solves a system of linear equations AX = B with a real symmetric matrix A using the factorization A = UDUT or A = LDL*T computed by SSYTRF and converted by SSYCONV.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| real(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| integer(kind=ilp), | intent(in) | :: | ipiv(*) | |||
| real(kind=sp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| real(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
ZSYTRS2 solves a system of linear equations AX = B with a complex symmetric matrix A using the factorization A = UDUT or A = LDL*T computed by ZSYTRF and converted by ZSYCONV.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| complex(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| integer(kind=ilp), | intent(in) | :: | ipiv(*) | |||
| complex(kind=dp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| complex(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
SYTRS_3 solves a system of linear equations A * X = B with a complex symmetric matrix A using the factorization computed by CSYTRF_RK or CSYTRF_BK: A = PUD(UT)(PT) or A = PLD*(LT)(PT), where U (or L) is unit upper (or lower) triangular matrix, UT (or LT) is the transpose of U (or L), P is a permutation matrix, P*T is the transpose of P, and D is symmetric and block diagonal with 1-by-1 and 2-by-2 diagonal blocks. This algorithm is using Level 3 BLAS.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| complex(kind=sp), | intent(in) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=sp), | intent(in) | :: | e(*) | |||
| integer(kind=ilp), | intent(in) | :: | ipiv(*) | |||
| complex(kind=sp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| real(kind=dp), | intent(in) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=dp), | intent(in) | :: | e(*) | |||
| integer(kind=ilp), | intent(in) | :: | ipiv(*) | |||
| real(kind=dp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| real(kind=sp), | intent(in) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=sp), | intent(in) | :: | e(*) | |||
| integer(kind=ilp), | intent(in) | :: | ipiv(*) | |||
| real(kind=sp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| complex(kind=dp), | intent(in) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=dp), | intent(in) | :: | e(*) | |||
| integer(kind=ilp), | intent(in) | :: | ipiv(*) | |||
| complex(kind=dp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| integer(kind=ilp), | intent(out) | :: | info |
CSYTRS_3 solves a system of linear equations A * X = B with a complex symmetric matrix A using the factorization computed by CSYTRF_RK or CSYTRF_BK: A = PUD(UT)(PT) or A = PLD*(LT)(PT), where U (or L) is unit upper (or lower) triangular matrix, UT (or LT) is the transpose of U (or L), P is a permutation matrix, P*T is the transpose of P, and D is symmetric and block diagonal with 1-by-1 and 2-by-2 diagonal blocks. This algorithm is using Level 3 BLAS.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| complex(kind=sp), | intent(in) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=sp), | intent(in) | :: | e(*) | |||
| integer(kind=ilp), | intent(in) | :: | ipiv(*) | |||
| complex(kind=sp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| integer(kind=ilp), | intent(out) | :: | info |
DSYTRS_3 solves a system of linear equations A * X = B with a real symmetric matrix A using the factorization computed by DSYTRF_RK or DSYTRF_BK: A = PUD(UT)(PT) or A = PLD*(LT)(PT), where U (or L) is unit upper (or lower) triangular matrix, UT (or LT) is the transpose of U (or L), P is a permutation matrix, P*T is the transpose of P, and D is symmetric and block diagonal with 1-by-1 and 2-by-2 diagonal blocks. This algorithm is using Level 3 BLAS.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| real(kind=dp), | intent(in) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=dp), | intent(in) | :: | e(*) | |||
| integer(kind=ilp), | intent(in) | :: | ipiv(*) | |||
| real(kind=dp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| integer(kind=ilp), | intent(out) | :: | info |
SSYTRS_3 solves a system of linear equations A * X = B with a real symmetric matrix A using the factorization computed by SSYTRF_RK or SSYTRF_BK: A = PUD(UT)(PT) or A = PLD*(LT)(PT), where U (or L) is unit upper (or lower) triangular matrix, UT (or LT) is the transpose of U (or L), P is a permutation matrix, P*T is the transpose of P, and D is symmetric and block diagonal with 1-by-1 and 2-by-2 diagonal blocks. This algorithm is using Level 3 BLAS.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| real(kind=sp), | intent(in) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=sp), | intent(in) | :: | e(*) | |||
| integer(kind=ilp), | intent(in) | :: | ipiv(*) | |||
| real(kind=sp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| integer(kind=ilp), | intent(out) | :: | info |
ZSYTRS_3 solves a system of linear equations A * X = B with a complex symmetric matrix A using the factorization computed by ZSYTRF_RK or ZSYTRF_BK: A = PUD(UT)(PT) or A = PLD*(LT)(PT), where U (or L) is unit upper (or lower) triangular matrix, UT (or LT) is the transpose of U (or L), P is a permutation matrix, P*T is the transpose of P, and D is symmetric and block diagonal with 1-by-1 and 2-by-2 diagonal blocks. This algorithm is using Level 3 BLAS.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| complex(kind=dp), | intent(in) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=dp), | intent(in) | :: | e(*) | |||
| integer(kind=ilp), | intent(in) | :: | ipiv(*) | |||
| complex(kind=dp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| integer(kind=ilp), | intent(out) | :: | info |
SYTRS_AA solves a system of linear equations AX = B with a complex symmetric matrix A using the factorization A = UTTU or A = LTL*T computed by CSYTRF_AA.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| complex(kind=sp), | intent(in) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| integer(kind=ilp), | intent(in) | :: | ipiv(*) | |||
| complex(kind=sp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| complex(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| real(kind=dp), | intent(in) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| integer(kind=ilp), | intent(in) | :: | ipiv(*) | |||
| real(kind=dp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| real(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| real(kind=sp), | intent(in) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| integer(kind=ilp), | intent(in) | :: | ipiv(*) | |||
| real(kind=sp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| real(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| complex(kind=dp), | intent(in) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| integer(kind=ilp), | intent(in) | :: | ipiv(*) | |||
| complex(kind=dp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| complex(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
CSYTRS_AA solves a system of linear equations AX = B with a complex symmetric matrix A using the factorization A = UTTU or A = LTL*T computed by CSYTRF_AA.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| complex(kind=sp), | intent(in) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| integer(kind=ilp), | intent(in) | :: | ipiv(*) | |||
| complex(kind=sp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| complex(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
DSYTRS_AA solves a system of linear equations AX = B with a real symmetric matrix A using the factorization A = UTTU or A = LTL*T computed by DSYTRF_AA.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| real(kind=dp), | intent(in) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| integer(kind=ilp), | intent(in) | :: | ipiv(*) | |||
| real(kind=dp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| real(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
SSYTRS_AA solves a system of linear equations AX = B with a real symmetric matrix A using the factorization A = UTTU or A = LTL*T computed by SSYTRF_AA.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| real(kind=sp), | intent(in) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| integer(kind=ilp), | intent(in) | :: | ipiv(*) | |||
| real(kind=sp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| real(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
ZSYTRS_AA solves a system of linear equations AX = B with a complex symmetric matrix A using the factorization A = UTTU or A = LTL*T computed by ZSYTRF_AA.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| complex(kind=dp), | intent(in) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| integer(kind=ilp), | intent(in) | :: | ipiv(*) | |||
| complex(kind=dp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| complex(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
SYTRS_ROOK solves a system of linear equations AX = B with a complex symmetric matrix A using the factorization A = UDUT or A = LDL*T computed by CSYTRF_ROOK.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| complex(kind=sp), | intent(in) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| integer(kind=ilp), | intent(in) | :: | ipiv(*) | |||
| complex(kind=sp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| real(kind=dp), | intent(in) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| integer(kind=ilp), | intent(in) | :: | ipiv(*) | |||
| real(kind=dp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| real(kind=sp), | intent(in) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| integer(kind=ilp), | intent(in) | :: | ipiv(*) | |||
| real(kind=sp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| complex(kind=dp), | intent(in) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| integer(kind=ilp), | intent(in) | :: | ipiv(*) | |||
| complex(kind=dp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| integer(kind=ilp), | intent(out) | :: | info |
CSYTRS_ROOK solves a system of linear equations AX = B with a complex symmetric matrix A using the factorization A = UDUT or A = LDL*T computed by CSYTRF_ROOK.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| complex(kind=sp), | intent(in) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| integer(kind=ilp), | intent(in) | :: | ipiv(*) | |||
| complex(kind=sp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| integer(kind=ilp), | intent(out) | :: | info |
DSYTRS_ROOK solves a system of linear equations AX = B with a real symmetric matrix A using the factorization A = UDUT or A = LDL*T computed by DSYTRF_ROOK.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| real(kind=dp), | intent(in) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| integer(kind=ilp), | intent(in) | :: | ipiv(*) | |||
| real(kind=dp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| integer(kind=ilp), | intent(out) | :: | info |
SSYTRS_ROOK solves a system of linear equations AX = B with a real symmetric matrix A using the factorization A = UDUT or A = LDL*T computed by SSYTRF_ROOK.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| real(kind=sp), | intent(in) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| integer(kind=ilp), | intent(in) | :: | ipiv(*) | |||
| real(kind=sp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| integer(kind=ilp), | intent(out) | :: | info |
ZSYTRS_ROOK solves a system of linear equations AX = B with a complex symmetric matrix A using the factorization A = UDUT or A = LDL*T computed by ZSYTRF_ROOK.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| complex(kind=dp), | intent(in) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| integer(kind=ilp), | intent(in) | :: | ipiv(*) | |||
| complex(kind=dp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| integer(kind=ilp), | intent(out) | :: | info |
TBCON estimates the reciprocal of the condition number of a triangular band matrix A, in either the 1-norm or the infinity-norm. The norm of A is computed and an estimate is obtained for norm(inv(A)), then the reciprocal of the condition number is computed as RCOND = 1 / ( norm(A) * norm(inv(A)) ).
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | norm | |||
| character, | intent(in) | :: | uplo | |||
| character, | intent(in) | :: | diag | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | kd | |||
| complex(kind=sp), | intent(in) | :: | ab(ldab,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldab | |||
| real(kind=sp), | intent(out) | :: | rcond | |||
| complex(kind=sp), | intent(out) | :: | work(*) | |||
| real(kind=sp), | intent(out) | :: | rwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | norm | |||
| character, | intent(in) | :: | uplo | |||
| character, | intent(in) | :: | diag | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | kd | |||
| real(kind=dp), | intent(in) | :: | ab(ldab,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldab | |||
| real(kind=dp), | intent(out) | :: | rcond | |||
| real(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | iwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | norm | |||
| character, | intent(in) | :: | uplo | |||
| character, | intent(in) | :: | diag | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | kd | |||
| real(kind=sp), | intent(in) | :: | ab(ldab,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldab | |||
| real(kind=sp), | intent(out) | :: | rcond | |||
| real(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | iwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | norm | |||
| character, | intent(in) | :: | uplo | |||
| character, | intent(in) | :: | diag | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | kd | |||
| complex(kind=dp), | intent(in) | :: | ab(ldab,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldab | |||
| real(kind=dp), | intent(out) | :: | rcond | |||
| complex(kind=dp), | intent(out) | :: | work(*) | |||
| real(kind=dp), | intent(out) | :: | rwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
CTBCON estimates the reciprocal of the condition number of a triangular band matrix A, in either the 1-norm or the infinity-norm. The norm of A is computed and an estimate is obtained for norm(inv(A)), then the reciprocal of the condition number is computed as RCOND = 1 / ( norm(A) * norm(inv(A)) ).
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | norm | |||
| character, | intent(in) | :: | uplo | |||
| character, | intent(in) | :: | diag | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | kd | |||
| complex(kind=sp), | intent(in) | :: | ab(ldab,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldab | |||
| real(kind=sp), | intent(out) | :: | rcond | |||
| complex(kind=sp), | intent(out) | :: | work(*) | |||
| real(kind=sp), | intent(out) | :: | rwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
DTBCON estimates the reciprocal of the condition number of a triangular band matrix A, in either the 1-norm or the infinity-norm. The norm of A is computed and an estimate is obtained for norm(inv(A)), then the reciprocal of the condition number is computed as RCOND = 1 / ( norm(A) * norm(inv(A)) ).
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | norm | |||
| character, | intent(in) | :: | uplo | |||
| character, | intent(in) | :: | diag | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | kd | |||
| real(kind=dp), | intent(in) | :: | ab(ldab,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldab | |||
| real(kind=dp), | intent(out) | :: | rcond | |||
| real(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | iwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
STBCON estimates the reciprocal of the condition number of a triangular band matrix A, in either the 1-norm or the infinity-norm. The norm of A is computed and an estimate is obtained for norm(inv(A)), then the reciprocal of the condition number is computed as RCOND = 1 / ( norm(A) * norm(inv(A)) ).
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | norm | |||
| character, | intent(in) | :: | uplo | |||
| character, | intent(in) | :: | diag | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | kd | |||
| real(kind=sp), | intent(in) | :: | ab(ldab,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldab | |||
| real(kind=sp), | intent(out) | :: | rcond | |||
| real(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | iwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
ZTBCON estimates the reciprocal of the condition number of a triangular band matrix A, in either the 1-norm or the infinity-norm. The norm of A is computed and an estimate is obtained for norm(inv(A)), then the reciprocal of the condition number is computed as RCOND = 1 / ( norm(A) * norm(inv(A)) ).
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | norm | |||
| character, | intent(in) | :: | uplo | |||
| character, | intent(in) | :: | diag | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | kd | |||
| complex(kind=dp), | intent(in) | :: | ab(ldab,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldab | |||
| real(kind=dp), | intent(out) | :: | rcond | |||
| complex(kind=dp), | intent(out) | :: | work(*) | |||
| real(kind=dp), | intent(out) | :: | rwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
TBRFS provides error bounds and backward error estimates for the solution to a system of linear equations with a triangular band coefficient matrix. The solution matrix X must be computed by CTBTRS or some other means before entering this routine. TBRFS does not do iterative refinement because doing so cannot improve the backward error.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| character, | intent(in) | :: | trans | |||
| character, | intent(in) | :: | diag | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | kd | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| complex(kind=sp), | intent(in) | :: | ab(ldab,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldab | |||
| complex(kind=sp), | intent(in) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| complex(kind=sp), | intent(in) | :: | x(ldx,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldx | |||
| real(kind=sp), | intent(out) | :: | ferr(*) | |||
| real(kind=sp), | intent(out) | :: | berr(*) | |||
| complex(kind=sp), | intent(out) | :: | work(*) | |||
| real(kind=sp), | intent(out) | :: | rwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| character, | intent(in) | :: | trans | |||
| character, | intent(in) | :: | diag | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | kd | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| real(kind=dp), | intent(in) | :: | ab(ldab,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldab | |||
| real(kind=dp), | intent(in) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| real(kind=dp), | intent(in) | :: | x(ldx,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldx | |||
| real(kind=dp), | intent(out) | :: | ferr(*) | |||
| real(kind=dp), | intent(out) | :: | berr(*) | |||
| real(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | iwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| character, | intent(in) | :: | trans | |||
| character, | intent(in) | :: | diag | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | kd | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| real(kind=sp), | intent(in) | :: | ab(ldab,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldab | |||
| real(kind=sp), | intent(in) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| real(kind=sp), | intent(in) | :: | x(ldx,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldx | |||
| real(kind=sp), | intent(out) | :: | ferr(*) | |||
| real(kind=sp), | intent(out) | :: | berr(*) | |||
| real(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | iwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| character, | intent(in) | :: | trans | |||
| character, | intent(in) | :: | diag | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | kd | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| complex(kind=dp), | intent(in) | :: | ab(ldab,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldab | |||
| complex(kind=dp), | intent(in) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| complex(kind=dp), | intent(in) | :: | x(ldx,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldx | |||
| real(kind=dp), | intent(out) | :: | ferr(*) | |||
| real(kind=dp), | intent(out) | :: | berr(*) | |||
| complex(kind=dp), | intent(out) | :: | work(*) | |||
| real(kind=dp), | intent(out) | :: | rwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
CTBRFS provides error bounds and backward error estimates for the solution to a system of linear equations with a triangular band coefficient matrix. The solution matrix X must be computed by CTBTRS or some other means before entering this routine. CTBRFS does not do iterative refinement because doing so cannot improve the backward error.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| character, | intent(in) | :: | trans | |||
| character, | intent(in) | :: | diag | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | kd | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| complex(kind=sp), | intent(in) | :: | ab(ldab,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldab | |||
| complex(kind=sp), | intent(in) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| complex(kind=sp), | intent(in) | :: | x(ldx,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldx | |||
| real(kind=sp), | intent(out) | :: | ferr(*) | |||
| real(kind=sp), | intent(out) | :: | berr(*) | |||
| complex(kind=sp), | intent(out) | :: | work(*) | |||
| real(kind=sp), | intent(out) | :: | rwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
DTBRFS provides error bounds and backward error estimates for the solution to a system of linear equations with a triangular band coefficient matrix. The solution matrix X must be computed by DTBTRS or some other means before entering this routine. DTBRFS does not do iterative refinement because doing so cannot improve the backward error.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| character, | intent(in) | :: | trans | |||
| character, | intent(in) | :: | diag | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | kd | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| real(kind=dp), | intent(in) | :: | ab(ldab,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldab | |||
| real(kind=dp), | intent(in) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| real(kind=dp), | intent(in) | :: | x(ldx,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldx | |||
| real(kind=dp), | intent(out) | :: | ferr(*) | |||
| real(kind=dp), | intent(out) | :: | berr(*) | |||
| real(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | iwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
STBRFS provides error bounds and backward error estimates for the solution to a system of linear equations with a triangular band coefficient matrix. The solution matrix X must be computed by STBTRS or some other means before entering this routine. STBRFS does not do iterative refinement because doing so cannot improve the backward error.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| character, | intent(in) | :: | trans | |||
| character, | intent(in) | :: | diag | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | kd | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| real(kind=sp), | intent(in) | :: | ab(ldab,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldab | |||
| real(kind=sp), | intent(in) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| real(kind=sp), | intent(in) | :: | x(ldx,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldx | |||
| real(kind=sp), | intent(out) | :: | ferr(*) | |||
| real(kind=sp), | intent(out) | :: | berr(*) | |||
| real(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | iwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
ZTBRFS provides error bounds and backward error estimates for the solution to a system of linear equations with a triangular band coefficient matrix. The solution matrix X must be computed by ZTBTRS or some other means before entering this routine. ZTBRFS does not do iterative refinement because doing so cannot improve the backward error.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| character, | intent(in) | :: | trans | |||
| character, | intent(in) | :: | diag | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | kd | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| complex(kind=dp), | intent(in) | :: | ab(ldab,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldab | |||
| complex(kind=dp), | intent(in) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| complex(kind=dp), | intent(in) | :: | x(ldx,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldx | |||
| real(kind=dp), | intent(out) | :: | ferr(*) | |||
| real(kind=dp), | intent(out) | :: | berr(*) | |||
| complex(kind=dp), | intent(out) | :: | work(*) | |||
| real(kind=dp), | intent(out) | :: | rwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
TBTRS solves a triangular system of the form A * X = B, AT * X = B, or AH * X = B, where A is a triangular band matrix of order N, and B is an N-by-NRHS matrix. A check is made to verify that A is nonsingular.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| character, | intent(in) | :: | trans | |||
| character, | intent(in) | :: | diag | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | kd | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| complex(kind=sp), | intent(in) | :: | ab(ldab,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldab | |||
| complex(kind=sp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| character, | intent(in) | :: | trans | |||
| character, | intent(in) | :: | diag | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | kd | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| real(kind=dp), | intent(in) | :: | ab(ldab,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldab | |||
| real(kind=dp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| character, | intent(in) | :: | trans | |||
| character, | intent(in) | :: | diag | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | kd | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| real(kind=sp), | intent(in) | :: | ab(ldab,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldab | |||
| real(kind=sp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| character, | intent(in) | :: | trans | |||
| character, | intent(in) | :: | diag | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | kd | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| complex(kind=dp), | intent(in) | :: | ab(ldab,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldab | |||
| complex(kind=dp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| integer(kind=ilp), | intent(out) | :: | info |
CTBTRS solves a triangular system of the form A * X = B, AT * X = B, or AH * X = B, where A is a triangular band matrix of order N, and B is an N-by-NRHS matrix. A check is made to verify that A is nonsingular.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| character, | intent(in) | :: | trans | |||
| character, | intent(in) | :: | diag | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | kd | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| complex(kind=sp), | intent(in) | :: | ab(ldab,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldab | |||
| complex(kind=sp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| integer(kind=ilp), | intent(out) | :: | info |
DTBTRS solves a triangular system of the form A * X = B or A**T * X = B, where A is a triangular band matrix of order N, and B is an N-by NRHS matrix. A check is made to verify that A is nonsingular.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| character, | intent(in) | :: | trans | |||
| character, | intent(in) | :: | diag | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | kd | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| real(kind=dp), | intent(in) | :: | ab(ldab,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldab | |||
| real(kind=dp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| integer(kind=ilp), | intent(out) | :: | info |
STBTRS solves a triangular system of the form A * X = B or A**T * X = B, where A is a triangular band matrix of order N, and B is an N-by NRHS matrix. A check is made to verify that A is nonsingular.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| character, | intent(in) | :: | trans | |||
| character, | intent(in) | :: | diag | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | kd | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| real(kind=sp), | intent(in) | :: | ab(ldab,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldab | |||
| real(kind=sp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| integer(kind=ilp), | intent(out) | :: | info |
ZTBTRS solves a triangular system of the form A * X = B, AT * X = B, or AH * X = B, where A is a triangular band matrix of order N, and B is an N-by-NRHS matrix. A check is made to verify that A is nonsingular.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| character, | intent(in) | :: | trans | |||
| character, | intent(in) | :: | diag | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | kd | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| complex(kind=dp), | intent(in) | :: | ab(ldab,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldab | |||
| complex(kind=dp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| integer(kind=ilp), | intent(out) | :: | info |
Level 3 BLAS like routine for A in RFP Format. TFSM solves the matrix equation op( A )X = alphaB or Xop( A ) = alphaB where alpha is a scalar, X and B are m by n matrices, A is a unit, or non-unit, upper or lower triangular matrix and op( A ) is one of op( A ) = A or op( A ) = A**H. A is in Rectangular Full Packed (RFP) Format. The matrix X is overwritten on B.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | transr | |||
| character, | intent(in) | :: | side | |||
| character, | intent(in) | :: | uplo | |||
| character, | intent(in) | :: | trans | |||
| character, | intent(in) | :: | diag | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=sp), | intent(in) | :: | alpha | |||
| complex(kind=sp), | intent(in) | :: | a(0:*) | |||
| complex(kind=sp), | intent(inout) | :: | b(0:ldb-1,0:*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | transr | |||
| character, | intent(in) | :: | side | |||
| character, | intent(in) | :: | uplo | |||
| character, | intent(in) | :: | trans | |||
| character, | intent(in) | :: | diag | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=dp), | intent(in) | :: | alpha | |||
| real(kind=dp), | intent(in) | :: | a(0:*) | |||
| real(kind=dp), | intent(inout) | :: | b(0:ldb-1,0:*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | transr | |||
| character, | intent(in) | :: | side | |||
| character, | intent(in) | :: | uplo | |||
| character, | intent(in) | :: | trans | |||
| character, | intent(in) | :: | diag | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=sp), | intent(in) | :: | alpha | |||
| real(kind=sp), | intent(in) | :: | a(0:*) | |||
| real(kind=sp), | intent(inout) | :: | b(0:ldb-1,0:*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | transr | |||
| character, | intent(in) | :: | side | |||
| character, | intent(in) | :: | uplo | |||
| character, | intent(in) | :: | trans | |||
| character, | intent(in) | :: | diag | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=dp), | intent(in) | :: | alpha | |||
| complex(kind=dp), | intent(in) | :: | a(0:*) | |||
| complex(kind=dp), | intent(inout) | :: | b(0:ldb-1,0:*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb |
Level 3 BLAS like routine for A in RFP Format. CTFSM solves the matrix equation op( A )X = alphaB or Xop( A ) = alphaB where alpha is a scalar, X and B are m by n matrices, A is a unit, or non-unit, upper or lower triangular matrix and op( A ) is one of op( A ) = A or op( A ) = A**H. A is in Rectangular Full Packed (RFP) Format. The matrix X is overwritten on B.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | transr | |||
| character, | intent(in) | :: | side | |||
| character, | intent(in) | :: | uplo | |||
| character, | intent(in) | :: | trans | |||
| character, | intent(in) | :: | diag | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=sp), | intent(in) | :: | alpha | |||
| complex(kind=sp), | intent(in) | :: | a(0:*) | |||
| complex(kind=sp), | intent(inout) | :: | b(0:ldb-1,0:*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb |
Level 3 BLAS like routine for A in RFP Format. DTFSM solves the matrix equation op( A )X = alphaB or Xop( A ) = alphaB where alpha is a scalar, X and B are m by n matrices, A is a unit, or non-unit, upper or lower triangular matrix and op( A ) is one of op( A ) = A or op( A ) = A**T. A is in Rectangular Full Packed (RFP) Format. The matrix X is overwritten on B.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | transr | |||
| character, | intent(in) | :: | side | |||
| character, | intent(in) | :: | uplo | |||
| character, | intent(in) | :: | trans | |||
| character, | intent(in) | :: | diag | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=dp), | intent(in) | :: | alpha | |||
| real(kind=dp), | intent(in) | :: | a(0:*) | |||
| real(kind=dp), | intent(inout) | :: | b(0:ldb-1,0:*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb |
Level 3 BLAS like routine for A in RFP Format. STFSM solves the matrix equation op( A )X = alphaB or Xop( A ) = alphaB where alpha is a scalar, X and B are m by n matrices, A is a unit, or non-unit, upper or lower triangular matrix and op( A ) is one of op( A ) = A or op( A ) = A**T. A is in Rectangular Full Packed (RFP) Format. The matrix X is overwritten on B.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | transr | |||
| character, | intent(in) | :: | side | |||
| character, | intent(in) | :: | uplo | |||
| character, | intent(in) | :: | trans | |||
| character, | intent(in) | :: | diag | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=sp), | intent(in) | :: | alpha | |||
| real(kind=sp), | intent(in) | :: | a(0:*) | |||
| real(kind=sp), | intent(inout) | :: | b(0:ldb-1,0:*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb |
Level 3 BLAS like routine for A in RFP Format. ZTFSM solves the matrix equation op( A )X = alphaB or Xop( A ) = alphaB where alpha is a scalar, X and B are m by n matrices, A is a unit, or non-unit, upper or lower triangular matrix and op( A ) is one of op( A ) = A or op( A ) = A**H. A is in Rectangular Full Packed (RFP) Format. The matrix X is overwritten on B.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | transr | |||
| character, | intent(in) | :: | side | |||
| character, | intent(in) | :: | uplo | |||
| character, | intent(in) | :: | trans | |||
| character, | intent(in) | :: | diag | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=dp), | intent(in) | :: | alpha | |||
| complex(kind=dp), | intent(in) | :: | a(0:*) | |||
| complex(kind=dp), | intent(inout) | :: | b(0:ldb-1,0:*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb |
TFTRI computes the inverse of a triangular matrix A stored in RFP format. This is a Level 3 BLAS version of the algorithm.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | transr | |||
| character, | intent(in) | :: | uplo | |||
| character, | intent(in) | :: | diag | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=sp), | intent(inout) | :: | a(0:*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | transr | |||
| character, | intent(in) | :: | uplo | |||
| character, | intent(in) | :: | diag | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=dp), | intent(inout) | :: | a(0:*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | transr | |||
| character, | intent(in) | :: | uplo | |||
| character, | intent(in) | :: | diag | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=sp), | intent(inout) | :: | a(0:*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | transr | |||
| character, | intent(in) | :: | uplo | |||
| character, | intent(in) | :: | diag | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=dp), | intent(inout) | :: | a(0:*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
CTFTRI computes the inverse of a triangular matrix A stored in RFP format. This is a Level 3 BLAS version of the algorithm.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | transr | |||
| character, | intent(in) | :: | uplo | |||
| character, | intent(in) | :: | diag | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=sp), | intent(inout) | :: | a(0:*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
DTFTRI computes the inverse of a triangular matrix A stored in RFP format. This is a Level 3 BLAS version of the algorithm.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | transr | |||
| character, | intent(in) | :: | uplo | |||
| character, | intent(in) | :: | diag | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=dp), | intent(inout) | :: | a(0:*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
STFTRI computes the inverse of a triangular matrix A stored in RFP format. This is a Level 3 BLAS version of the algorithm.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | transr | |||
| character, | intent(in) | :: | uplo | |||
| character, | intent(in) | :: | diag | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=sp), | intent(inout) | :: | a(0:*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
ZTFTRI computes the inverse of a triangular matrix A stored in RFP format. This is a Level 3 BLAS version of the algorithm.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | transr | |||
| character, | intent(in) | :: | uplo | |||
| character, | intent(in) | :: | diag | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=dp), | intent(inout) | :: | a(0:*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
TFTTP copies a triangular matrix A from rectangular full packed format (TF) to standard packed format (TP).
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | transr | |||
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=sp), | intent(in) | :: | arf(0:*) | |||
| complex(kind=sp), | intent(out) | :: | ap(0:*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | transr | |||
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=dp), | intent(in) | :: | arf(0:*) | |||
| real(kind=dp), | intent(out) | :: | ap(0:*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | transr | |||
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=sp), | intent(in) | :: | arf(0:*) | |||
| real(kind=sp), | intent(out) | :: | ap(0:*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | transr | |||
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=dp), | intent(in) | :: | arf(0:*) | |||
| complex(kind=dp), | intent(out) | :: | ap(0:*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
CTFTTP copies a triangular matrix A from rectangular full packed format (TF) to standard packed format (TP).
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | transr | |||
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=sp), | intent(in) | :: | arf(0:*) | |||
| complex(kind=sp), | intent(out) | :: | ap(0:*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
DTFTTP copies a triangular matrix A from rectangular full packed format (TF) to standard packed format (TP).
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | transr | |||
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=dp), | intent(in) | :: | arf(0:*) | |||
| real(kind=dp), | intent(out) | :: | ap(0:*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
STFTTP copies a triangular matrix A from rectangular full packed format (TF) to standard packed format (TP).
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | transr | |||
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=sp), | intent(in) | :: | arf(0:*) | |||
| real(kind=sp), | intent(out) | :: | ap(0:*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
ZTFTTP copies a triangular matrix A from rectangular full packed format (TF) to standard packed format (TP).
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | transr | |||
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=dp), | intent(in) | :: | arf(0:*) | |||
| complex(kind=dp), | intent(out) | :: | ap(0:*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
TFTTR copies a triangular matrix A from rectangular full packed format (TF) to standard full format (TR).
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | transr | |||
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=sp), | intent(in) | :: | arf(0:*) | |||
| complex(kind=sp), | intent(out) | :: | a(0:lda-1,0:*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | transr | |||
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=dp), | intent(in) | :: | arf(0:*) | |||
| real(kind=dp), | intent(out) | :: | a(0:lda-1,0:*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | transr | |||
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=sp), | intent(in) | :: | arf(0:*) | |||
| real(kind=sp), | intent(out) | :: | a(0:lda-1,0:*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | transr | |||
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=dp), | intent(in) | :: | arf(0:*) | |||
| complex(kind=dp), | intent(out) | :: | a(0:lda-1,0:*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| integer(kind=ilp), | intent(out) | :: | info |
CTFTTR copies a triangular matrix A from rectangular full packed format (TF) to standard full format (TR).
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | transr | |||
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=sp), | intent(in) | :: | arf(0:*) | |||
| complex(kind=sp), | intent(out) | :: | a(0:lda-1,0:*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| integer(kind=ilp), | intent(out) | :: | info |
DTFTTR copies a triangular matrix A from rectangular full packed format (TF) to standard full format (TR).
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | transr | |||
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=dp), | intent(in) | :: | arf(0:*) | |||
| real(kind=dp), | intent(out) | :: | a(0:lda-1,0:*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| integer(kind=ilp), | intent(out) | :: | info |
STFTTR copies a triangular matrix A from rectangular full packed format (TF) to standard full format (TR).
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | transr | |||
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=sp), | intent(in) | :: | arf(0:*) | |||
| real(kind=sp), | intent(out) | :: | a(0:lda-1,0:*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| integer(kind=ilp), | intent(out) | :: | info |
ZTFTTR copies a triangular matrix A from rectangular full packed format (TF) to standard full format (TR).
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | transr | |||
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=dp), | intent(in) | :: | arf(0:*) | |||
| complex(kind=dp), | intent(out) | :: | a(0:lda-1,0:*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| integer(kind=ilp), | intent(out) | :: | info |
TGEVC computes some or all of the right and/or left eigenvectors of a pair of complex matrices (S,P), where S and P are upper triangular. Matrix pairs of this type are produced by the generalized Schur factorization of a complex matrix pair (A,B): A = QSZH, B = QPZH as computed by CGGHRD + CHGEQZ. The right eigenvector x and the left eigenvector y of (S,P) corresponding to an eigenvalue w are defined by: Sx = wPx, (yH)S = w(yH)P, where yH denotes the conjugate tranpose of y. The eigenvalues are not input to this routine, but are computed directly from the diagonal elements of S and P. This routine returns the matrices X and/or Y of right and left eigenvectors of (S,P), or the products ZX and/or QY, where Z and Q are input matrices. If Q and Z are the unitary factors from the generalized Schur factorization of a matrix pair (A,B), then ZX and QY are the matrices of right and left eigenvectors of (A,B).
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | side | |||
| character, | intent(in) | :: | howmny | |||
| logical(kind=lk), | intent(in) | :: | select(*) | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=sp), | intent(in) | :: | s(lds,*) | |||
| integer(kind=ilp), | intent(in) | :: | lds | |||
| complex(kind=sp), | intent(in) | :: | p(ldp,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldp | |||
| complex(kind=sp), | intent(inout) | :: | vl(ldvl,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldvl | |||
| complex(kind=sp), | intent(inout) | :: | vr(ldvr,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldvr | |||
| integer(kind=ilp), | intent(in) | :: | mm | |||
| integer(kind=ilp), | intent(out) | :: | m | |||
| complex(kind=sp), | intent(out) | :: | work(*) | |||
| real(kind=sp), | intent(out) | :: | rwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | side | |||
| character, | intent(in) | :: | howmny | |||
| logical(kind=lk), | intent(in) | :: | select(*) | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=dp), | intent(in) | :: | s(lds,*) | |||
| integer(kind=ilp), | intent(in) | :: | lds | |||
| real(kind=dp), | intent(in) | :: | p(ldp,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldp | |||
| real(kind=dp), | intent(inout) | :: | vl(ldvl,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldvl | |||
| real(kind=dp), | intent(inout) | :: | vr(ldvr,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldvr | |||
| integer(kind=ilp), | intent(in) | :: | mm | |||
| integer(kind=ilp), | intent(out) | :: | m | |||
| real(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | side | |||
| character, | intent(in) | :: | howmny | |||
| logical(kind=lk), | intent(in) | :: | select(*) | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=sp), | intent(in) | :: | s(lds,*) | |||
| integer(kind=ilp), | intent(in) | :: | lds | |||
| real(kind=sp), | intent(in) | :: | p(ldp,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldp | |||
| real(kind=sp), | intent(inout) | :: | vl(ldvl,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldvl | |||
| real(kind=sp), | intent(inout) | :: | vr(ldvr,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldvr | |||
| integer(kind=ilp), | intent(in) | :: | mm | |||
| integer(kind=ilp), | intent(out) | :: | m | |||
| real(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | side | |||
| character, | intent(in) | :: | howmny | |||
| logical(kind=lk), | intent(in) | :: | select(*) | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=dp), | intent(in) | :: | s(lds,*) | |||
| integer(kind=ilp), | intent(in) | :: | lds | |||
| complex(kind=dp), | intent(in) | :: | p(ldp,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldp | |||
| complex(kind=dp), | intent(inout) | :: | vl(ldvl,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldvl | |||
| complex(kind=dp), | intent(inout) | :: | vr(ldvr,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldvr | |||
| integer(kind=ilp), | intent(in) | :: | mm | |||
| integer(kind=ilp), | intent(out) | :: | m | |||
| complex(kind=dp), | intent(out) | :: | work(*) | |||
| real(kind=dp), | intent(out) | :: | rwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
CTGEVC computes some or all of the right and/or left eigenvectors of a pair of complex matrices (S,P), where S and P are upper triangular. Matrix pairs of this type are produced by the generalized Schur factorization of a complex matrix pair (A,B): A = QSZH, B = QPZH as computed by CGGHRD + CHGEQZ. The right eigenvector x and the left eigenvector y of (S,P) corresponding to an eigenvalue w are defined by: Sx = wPx, (yH)S = w(yH)P, where yH denotes the conjugate tranpose of y. The eigenvalues are not input to this routine, but are computed directly from the diagonal elements of S and P. This routine returns the matrices X and/or Y of right and left eigenvectors of (S,P), or the products ZX and/or QY, where Z and Q are input matrices. If Q and Z are the unitary factors from the generalized Schur factorization of a matrix pair (A,B), then ZX and QY are the matrices of right and left eigenvectors of (A,B).
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | side | |||
| character, | intent(in) | :: | howmny | |||
| logical(kind=lk), | intent(in) | :: | select(*) | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=sp), | intent(in) | :: | s(lds,*) | |||
| integer(kind=ilp), | intent(in) | :: | lds | |||
| complex(kind=sp), | intent(in) | :: | p(ldp,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldp | |||
| complex(kind=sp), | intent(inout) | :: | vl(ldvl,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldvl | |||
| complex(kind=sp), | intent(inout) | :: | vr(ldvr,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldvr | |||
| integer(kind=ilp), | intent(in) | :: | mm | |||
| integer(kind=ilp), | intent(out) | :: | m | |||
| complex(kind=sp), | intent(out) | :: | work(*) | |||
| real(kind=sp), | intent(out) | :: | rwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
DTGEVC computes some or all of the right and/or left eigenvectors of a pair of real matrices (S,P), where S is a quasi-triangular matrix and P is upper triangular. Matrix pairs of this type are produced by the generalized Schur factorization of a matrix pair (A,B): A = QSZT, B = QPZT as computed by DGGHRD + DHGEQZ. The right eigenvector x and the left eigenvector y of (S,P) corresponding to an eigenvalue w are defined by: Sx = wPx, (yH)S = w(yH)P, where yH denotes the conjugate tranpose of y. The eigenvalues are not input to this routine, but are computed directly from the diagonal blocks of S and P. This routine returns the matrices X and/or Y of right and left eigenvectors of (S,P), or the products ZX and/or QY, where Z and Q are input matrices. If Q and Z are the orthogonal factors from the generalized Schur factorization of a matrix pair (A,B), then ZX and QY are the matrices of right and left eigenvectors of (A,B).
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | side | |||
| character, | intent(in) | :: | howmny | |||
| logical(kind=lk), | intent(in) | :: | select(*) | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=dp), | intent(in) | :: | s(lds,*) | |||
| integer(kind=ilp), | intent(in) | :: | lds | |||
| real(kind=dp), | intent(in) | :: | p(ldp,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldp | |||
| real(kind=dp), | intent(inout) | :: | vl(ldvl,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldvl | |||
| real(kind=dp), | intent(inout) | :: | vr(ldvr,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldvr | |||
| integer(kind=ilp), | intent(in) | :: | mm | |||
| integer(kind=ilp), | intent(out) | :: | m | |||
| real(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
STGEVC computes some or all of the right and/or left eigenvectors of a pair of real matrices (S,P), where S is a quasi-triangular matrix and P is upper triangular. Matrix pairs of this type are produced by the generalized Schur factorization of a matrix pair (A,B): A = QSZT, B = QPZT as computed by SGGHRD + SHGEQZ. The right eigenvector x and the left eigenvector y of (S,P) corresponding to an eigenvalue w are defined by: Sx = wPx, (yH)S = w(yH)P, where yH denotes the conjugate tranpose of y. The eigenvalues are not input to this routine, but are computed directly from the diagonal blocks of S and P. This routine returns the matrices X and/or Y of right and left eigenvectors of (S,P), or the products ZX and/or QY, where Z and Q are input matrices. If Q and Z are the orthogonal factors from the generalized Schur factorization of a matrix pair (A,B), then ZX and QY are the matrices of right and left eigenvectors of (A,B).
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | side | |||
| character, | intent(in) | :: | howmny | |||
| logical(kind=lk), | intent(in) | :: | select(*) | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=sp), | intent(in) | :: | s(lds,*) | |||
| integer(kind=ilp), | intent(in) | :: | lds | |||
| real(kind=sp), | intent(in) | :: | p(ldp,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldp | |||
| real(kind=sp), | intent(inout) | :: | vl(ldvl,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldvl | |||
| real(kind=sp), | intent(inout) | :: | vr(ldvr,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldvr | |||
| integer(kind=ilp), | intent(in) | :: | mm | |||
| integer(kind=ilp), | intent(out) | :: | m | |||
| real(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
ZTGEVC computes some or all of the right and/or left eigenvectors of a pair of complex matrices (S,P), where S and P are upper triangular. Matrix pairs of this type are produced by the generalized Schur factorization of a complex matrix pair (A,B): A = QSZH, B = QPZH as computed by ZGGHRD + ZHGEQZ. The right eigenvector x and the left eigenvector y of (S,P) corresponding to an eigenvalue w are defined by: Sx = wPx, (yH)S = w(yH)P, where yH denotes the conjugate tranpose of y. The eigenvalues are not input to this routine, but are computed directly from the diagonal elements of S and P. This routine returns the matrices X and/or Y of right and left eigenvectors of (S,P), or the products ZX and/or QY, where Z and Q are input matrices. If Q and Z are the unitary factors from the generalized Schur factorization of a matrix pair (A,B), then ZX and QY are the matrices of right and left eigenvectors of (A,B).
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | side | |||
| character, | intent(in) | :: | howmny | |||
| logical(kind=lk), | intent(in) | :: | select(*) | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=dp), | intent(in) | :: | s(lds,*) | |||
| integer(kind=ilp), | intent(in) | :: | lds | |||
| complex(kind=dp), | intent(in) | :: | p(ldp,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldp | |||
| complex(kind=dp), | intent(inout) | :: | vl(ldvl,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldvl | |||
| complex(kind=dp), | intent(inout) | :: | vr(ldvr,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldvr | |||
| integer(kind=ilp), | intent(in) | :: | mm | |||
| integer(kind=ilp), | intent(out) | :: | m | |||
| complex(kind=dp), | intent(out) | :: | work(*) | |||
| real(kind=dp), | intent(out) | :: | rwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
TGEXC reorders the generalized Schur decomposition of a complex matrix pair (A,B), using an unitary equivalence transformation (A, B) := Q * (A, B) * ZH, so that the diagonal block of (A, B) with row index IFST is moved to row ILST. (A, B) must be in generalized Schur canonical form, that is, A and B are both upper triangular. Optionally, the matrices Q and Z of generalized Schur vectors are updated. Q(in) * A(in) * Z(in)H = Q(out) * A(out) * Z(out)H Q(in) * B(in) * Z(in)H = Q(out) * B(out) * Z(out)**H
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| logical(kind=lk), | intent(in) | :: | wantq | |||
| logical(kind=lk), | intent(in) | :: | wantz | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=sp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| complex(kind=sp), | intent(inout) | :: | q(ldq,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldq | |||
| complex(kind=sp), | intent(inout) | :: | z(ldz,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldz | |||
| integer(kind=ilp), | intent(in) | :: | ifst | |||
| integer(kind=ilp), | intent(inout) | :: | ilst | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| logical(kind=lk), | intent(in) | :: | wantq | |||
| logical(kind=lk), | intent(in) | :: | wantz | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=dp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| real(kind=dp), | intent(inout) | :: | q(ldq,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldq | |||
| real(kind=dp), | intent(inout) | :: | z(ldz,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldz | |||
| integer(kind=ilp), | intent(inout) | :: | ifst | |||
| integer(kind=ilp), | intent(inout) | :: | ilst | |||
| real(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| logical(kind=lk), | intent(in) | :: | wantq | |||
| logical(kind=lk), | intent(in) | :: | wantz | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=sp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| real(kind=sp), | intent(inout) | :: | q(ldq,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldq | |||
| real(kind=sp), | intent(inout) | :: | z(ldz,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldz | |||
| integer(kind=ilp), | intent(inout) | :: | ifst | |||
| integer(kind=ilp), | intent(inout) | :: | ilst | |||
| real(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| logical(kind=lk), | intent(in) | :: | wantq | |||
| logical(kind=lk), | intent(in) | :: | wantz | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=dp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| complex(kind=dp), | intent(inout) | :: | q(ldq,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldq | |||
| complex(kind=dp), | intent(inout) | :: | z(ldz,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldz | |||
| integer(kind=ilp), | intent(in) | :: | ifst | |||
| integer(kind=ilp), | intent(inout) | :: | ilst | |||
| integer(kind=ilp), | intent(out) | :: | info |
CTGEXC reorders the generalized Schur decomposition of a complex matrix pair (A,B), using an unitary equivalence transformation (A, B) := Q * (A, B) * ZH, so that the diagonal block of (A, B) with row index IFST is moved to row ILST. (A, B) must be in generalized Schur canonical form, that is, A and B are both upper triangular. Optionally, the matrices Q and Z of generalized Schur vectors are updated. Q(in) * A(in) * Z(in)H = Q(out) * A(out) * Z(out)H Q(in) * B(in) * Z(in)H = Q(out) * B(out) * Z(out)**H
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| logical(kind=lk), | intent(in) | :: | wantq | |||
| logical(kind=lk), | intent(in) | :: | wantz | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=sp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| complex(kind=sp), | intent(inout) | :: | q(ldq,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldq | |||
| complex(kind=sp), | intent(inout) | :: | z(ldz,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldz | |||
| integer(kind=ilp), | intent(in) | :: | ifst | |||
| integer(kind=ilp), | intent(inout) | :: | ilst | |||
| integer(kind=ilp), | intent(out) | :: | info |
DTGEXC reorders the generalized real Schur decomposition of a real matrix pair (A,B) using an orthogonal equivalence transformation (A, B) = Q * (A, B) * ZT, so that the diagonal block of (A, B) with row index IFST is moved to row ILST. (A, B) must be in generalized real Schur canonical form (as returned by DGGES), i.e. A is block upper triangular with 1-by-1 and 2-by-2 diagonal blocks. B is upper triangular. Optionally, the matrices Q and Z of generalized Schur vectors are updated. Q(in) * A(in) * Z(in)T = Q(out) * A(out) * Z(out)T Q(in) * B(in) * Z(in)T = Q(out) * B(out) * Z(out)**T
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| logical(kind=lk), | intent(in) | :: | wantq | |||
| logical(kind=lk), | intent(in) | :: | wantz | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=dp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| real(kind=dp), | intent(inout) | :: | q(ldq,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldq | |||
| real(kind=dp), | intent(inout) | :: | z(ldz,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldz | |||
| integer(kind=ilp), | intent(inout) | :: | ifst | |||
| integer(kind=ilp), | intent(inout) | :: | ilst | |||
| real(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
STGEXC reorders the generalized real Schur decomposition of a real matrix pair (A,B) using an orthogonal equivalence transformation (A, B) = Q * (A, B) * ZT, so that the diagonal block of (A, B) with row index IFST is moved to row ILST. (A, B) must be in generalized real Schur canonical form (as returned by SGGES), i.e. A is block upper triangular with 1-by-1 and 2-by-2 diagonal blocks. B is upper triangular. Optionally, the matrices Q and Z of generalized Schur vectors are updated. Q(in) * A(in) * Z(in)T = Q(out) * A(out) * Z(out)T Q(in) * B(in) * Z(in)T = Q(out) * B(out) * Z(out)**T
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| logical(kind=lk), | intent(in) | :: | wantq | |||
| logical(kind=lk), | intent(in) | :: | wantz | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=sp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| real(kind=sp), | intent(inout) | :: | q(ldq,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldq | |||
| real(kind=sp), | intent(inout) | :: | z(ldz,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldz | |||
| integer(kind=ilp), | intent(inout) | :: | ifst | |||
| integer(kind=ilp), | intent(inout) | :: | ilst | |||
| real(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
ZTGEXC reorders the generalized Schur decomposition of a complex matrix pair (A,B), using an unitary equivalence transformation (A, B) := Q * (A, B) * ZH, so that the diagonal block of (A, B) with row index IFST is moved to row ILST. (A, B) must be in generalized Schur canonical form, that is, A and B are both upper triangular. Optionally, the matrices Q and Z of generalized Schur vectors are updated. Q(in) * A(in) * Z(in)H = Q(out) * A(out) * Z(out)H Q(in) * B(in) * Z(in)H = Q(out) * B(out) * Z(out)**H
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| logical(kind=lk), | intent(in) | :: | wantq | |||
| logical(kind=lk), | intent(in) | :: | wantz | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=dp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| complex(kind=dp), | intent(inout) | :: | q(ldq,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldq | |||
| complex(kind=dp), | intent(inout) | :: | z(ldz,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldz | |||
| integer(kind=ilp), | intent(in) | :: | ifst | |||
| integer(kind=ilp), | intent(inout) | :: | ilst | |||
| integer(kind=ilp), | intent(out) | :: | info |
TGSEN reorders the generalized Schur decomposition of a complex matrix pair (A, B) (in terms of an unitary equivalence trans- formation Q**H * (A, B) * Z), so that a selected cluster of eigenvalues appears in the leading diagonal blocks of the pair (A,B). The leading columns of Q and Z form unitary bases of the corresponding left and right eigenspaces (deflating subspaces). (A, B) must be in generalized Schur canonical form, that is, A and B are both upper triangular. TGSEN also computes the generalized eigenvalues w(j)= ALPHA(j) / BETA(j) of the reordered matrix pair (A, B). Optionally, the routine computes estimates of reciprocal condition numbers for eigenvalues and eigenspaces. These are Difu[(A11,B11), (A22,B22)] and Difl[(A11,B11), (A22,B22)], i.e. the separation(s) between the matrix pairs (A11, B11) and (A22,B22) that correspond to the selected cluster and the eigenvalues outside the cluster, resp., and norms of "projections" onto left and right eigenspaces w.r.t. the selected cluster in the (1,1)-block.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | ijob | |||
| logical(kind=lk), | intent(in) | :: | wantq | |||
| logical(kind=lk), | intent(in) | :: | wantz | |||
| logical(kind=lk), | intent(in) | :: | select(*) | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=sp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| complex(kind=sp), | intent(out) | :: | alpha(*) | |||
| complex(kind=sp), | intent(out) | :: | beta(*) | |||
| complex(kind=sp), | intent(inout) | :: | q(ldq,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldq | |||
| complex(kind=sp), | intent(inout) | :: | z(ldz,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldz | |||
| integer(kind=ilp), | intent(out) | :: | m | |||
| real(kind=sp), | intent(out) | :: | pl | |||
| real(kind=sp), | intent(out) | :: | pr | |||
| real(kind=sp), | intent(out) | :: | dif(*) | |||
| complex(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | iwork(*) | |||
| integer(kind=ilp), | intent(in) | :: | liwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | ijob | |||
| logical(kind=lk), | intent(in) | :: | wantq | |||
| logical(kind=lk), | intent(in) | :: | wantz | |||
| logical(kind=lk), | intent(in) | :: | select(*) | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=dp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| real(kind=dp), | intent(out) | :: | alphar(*) | |||
| real(kind=dp), | intent(out) | :: | alphai(*) | |||
| real(kind=dp), | intent(out) | :: | beta(*) | |||
| real(kind=dp), | intent(inout) | :: | q(ldq,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldq | |||
| real(kind=dp), | intent(inout) | :: | z(ldz,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldz | |||
| integer(kind=ilp), | intent(out) | :: | m | |||
| real(kind=dp), | intent(out) | :: | pl | |||
| real(kind=dp), | intent(out) | :: | pr | |||
| real(kind=dp), | intent(out) | :: | dif(*) | |||
| real(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | iwork(*) | |||
| integer(kind=ilp), | intent(in) | :: | liwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | ijob | |||
| logical(kind=lk), | intent(in) | :: | wantq | |||
| logical(kind=lk), | intent(in) | :: | wantz | |||
| logical(kind=lk), | intent(in) | :: | select(*) | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=sp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| real(kind=sp), | intent(out) | :: | alphar(*) | |||
| real(kind=sp), | intent(out) | :: | alphai(*) | |||
| real(kind=sp), | intent(out) | :: | beta(*) | |||
| real(kind=sp), | intent(inout) | :: | q(ldq,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldq | |||
| real(kind=sp), | intent(inout) | :: | z(ldz,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldz | |||
| integer(kind=ilp), | intent(out) | :: | m | |||
| real(kind=sp), | intent(out) | :: | pl | |||
| real(kind=sp), | intent(out) | :: | pr | |||
| real(kind=sp), | intent(out) | :: | dif(*) | |||
| real(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | iwork(*) | |||
| integer(kind=ilp), | intent(in) | :: | liwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | ijob | |||
| logical(kind=lk), | intent(in) | :: | wantq | |||
| logical(kind=lk), | intent(in) | :: | wantz | |||
| logical(kind=lk), | intent(in) | :: | select(*) | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=dp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| complex(kind=dp), | intent(out) | :: | alpha(*) | |||
| complex(kind=dp), | intent(out) | :: | beta(*) | |||
| complex(kind=dp), | intent(inout) | :: | q(ldq,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldq | |||
| complex(kind=dp), | intent(inout) | :: | z(ldz,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldz | |||
| integer(kind=ilp), | intent(out) | :: | m | |||
| real(kind=dp), | intent(out) | :: | pl | |||
| real(kind=dp), | intent(out) | :: | pr | |||
| real(kind=dp), | intent(out) | :: | dif(*) | |||
| complex(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | iwork(*) | |||
| integer(kind=ilp), | intent(in) | :: | liwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
CTGSEN reorders the generalized Schur decomposition of a complex matrix pair (A, B) (in terms of an unitary equivalence trans- formation Q**H * (A, B) * Z), so that a selected cluster of eigenvalues appears in the leading diagonal blocks of the pair (A,B). The leading columns of Q and Z form unitary bases of the corresponding left and right eigenspaces (deflating subspaces). (A, B) must be in generalized Schur canonical form, that is, A and B are both upper triangular. CTGSEN also computes the generalized eigenvalues w(j)= ALPHA(j) / BETA(j) of the reordered matrix pair (A, B). Optionally, the routine computes estimates of reciprocal condition numbers for eigenvalues and eigenspaces. These are Difu[(A11,B11), (A22,B22)] and Difl[(A11,B11), (A22,B22)], i.e. the separation(s) between the matrix pairs (A11, B11) and (A22,B22) that correspond to the selected cluster and the eigenvalues outside the cluster, resp., and norms of "projections" onto left and right eigenspaces w.r.t. the selected cluster in the (1,1)-block.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | ijob | |||
| logical(kind=lk), | intent(in) | :: | wantq | |||
| logical(kind=lk), | intent(in) | :: | wantz | |||
| logical(kind=lk), | intent(in) | :: | select(*) | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=sp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| complex(kind=sp), | intent(out) | :: | alpha(*) | |||
| complex(kind=sp), | intent(out) | :: | beta(*) | |||
| complex(kind=sp), | intent(inout) | :: | q(ldq,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldq | |||
| complex(kind=sp), | intent(inout) | :: | z(ldz,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldz | |||
| integer(kind=ilp), | intent(out) | :: | m | |||
| real(kind=sp), | intent(out) | :: | pl | |||
| real(kind=sp), | intent(out) | :: | pr | |||
| real(kind=sp), | intent(out) | :: | dif(*) | |||
| complex(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | iwork(*) | |||
| integer(kind=ilp), | intent(in) | :: | liwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
DTGSEN reorders the generalized real Schur decomposition of a real matrix pair (A, B) (in terms of an orthonormal equivalence trans- formation Q*T * (A, B) * Z), so that a selected cluster of eigenvalues appears in the leading diagonal blocks of the upper quasi-triangular matrix A and the upper triangular B. The leading columns of Q and Z form orthonormal bases of the corresponding left and right eigen- spaces (deflating subspaces). (A, B) must be in generalized real Schur canonical form (as returned by DGGES), i.e. A is block upper triangular with 1-by-1 and 2-by-2 diagonal blocks. B is upper triangular. DTGSEN also computes the generalized eigenvalues w(j) = (ALPHAR(j) + iALPHAI(j))/BETA(j) of the reordered matrix pair (A, B). Optionally, DTGSEN computes the estimates of reciprocal condition numbers for eigenvalues and eigenspaces. These are Difu[(A11,B11), (A22,B22)] and Difl[(A11,B11), (A22,B22)], i.e. the separation(s) between the matrix pairs (A11, B11) and (A22,B22) that correspond to the selected cluster and the eigenvalues outside the cluster, resp., and norms of "projections" onto left and right eigenspaces w.r.t. the selected cluster in the (1,1)-block.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | ijob | |||
| logical(kind=lk), | intent(in) | :: | wantq | |||
| logical(kind=lk), | intent(in) | :: | wantz | |||
| logical(kind=lk), | intent(in) | :: | select(*) | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=dp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| real(kind=dp), | intent(out) | :: | alphar(*) | |||
| real(kind=dp), | intent(out) | :: | alphai(*) | |||
| real(kind=dp), | intent(out) | :: | beta(*) | |||
| real(kind=dp), | intent(inout) | :: | q(ldq,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldq | |||
| real(kind=dp), | intent(inout) | :: | z(ldz,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldz | |||
| integer(kind=ilp), | intent(out) | :: | m | |||
| real(kind=dp), | intent(out) | :: | pl | |||
| real(kind=dp), | intent(out) | :: | pr | |||
| real(kind=dp), | intent(out) | :: | dif(*) | |||
| real(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | iwork(*) | |||
| integer(kind=ilp), | intent(in) | :: | liwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
STGSEN reorders the generalized real Schur decomposition of a real matrix pair (A, B) (in terms of an orthonormal equivalence trans- formation Q*T * (A, B) * Z), so that a selected cluster of eigenvalues appears in the leading diagonal blocks of the upper quasi-triangular matrix A and the upper triangular B. The leading columns of Q and Z form orthonormal bases of the corresponding left and right eigen- spaces (deflating subspaces). (A, B) must be in generalized real Schur canonical form (as returned by SGGES), i.e. A is block upper triangular with 1-by-1 and 2-by-2 diagonal blocks. B is upper triangular. STGSEN also computes the generalized eigenvalues w(j) = (ALPHAR(j) + iALPHAI(j))/BETA(j) of the reordered matrix pair (A, B). Optionally, STGSEN computes the estimates of reciprocal condition numbers for eigenvalues and eigenspaces. These are Difu[(A11,B11), (A22,B22)] and Difl[(A11,B11), (A22,B22)], i.e. the separation(s) between the matrix pairs (A11, B11) and (A22,B22) that correspond to the selected cluster and the eigenvalues outside the cluster, resp., and norms of "projections" onto left and right eigenspaces w.r.t. the selected cluster in the (1,1)-block.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | ijob | |||
| logical(kind=lk), | intent(in) | :: | wantq | |||
| logical(kind=lk), | intent(in) | :: | wantz | |||
| logical(kind=lk), | intent(in) | :: | select(*) | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=sp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| real(kind=sp), | intent(out) | :: | alphar(*) | |||
| real(kind=sp), | intent(out) | :: | alphai(*) | |||
| real(kind=sp), | intent(out) | :: | beta(*) | |||
| real(kind=sp), | intent(inout) | :: | q(ldq,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldq | |||
| real(kind=sp), | intent(inout) | :: | z(ldz,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldz | |||
| integer(kind=ilp), | intent(out) | :: | m | |||
| real(kind=sp), | intent(out) | :: | pl | |||
| real(kind=sp), | intent(out) | :: | pr | |||
| real(kind=sp), | intent(out) | :: | dif(*) | |||
| real(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | iwork(*) | |||
| integer(kind=ilp), | intent(in) | :: | liwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
ZTGSEN reorders the generalized Schur decomposition of a complex matrix pair (A, B) (in terms of an unitary equivalence trans- formation Q**H * (A, B) * Z), so that a selected cluster of eigenvalues appears in the leading diagonal blocks of the pair (A,B). The leading columns of Q and Z form unitary bases of the corresponding left and right eigenspaces (deflating subspaces). (A, B) must be in generalized Schur canonical form, that is, A and B are both upper triangular. ZTGSEN also computes the generalized eigenvalues w(j)= ALPHA(j) / BETA(j) of the reordered matrix pair (A, B). Optionally, the routine computes estimates of reciprocal condition numbers for eigenvalues and eigenspaces. These are Difu[(A11,B11), (A22,B22)] and Difl[(A11,B11), (A22,B22)], i.e. the separation(s) between the matrix pairs (A11, B11) and (A22,B22) that correspond to the selected cluster and the eigenvalues outside the cluster, resp., and norms of "projections" onto left and right eigenspaces w.r.t. the selected cluster in the (1,1)-block.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | ijob | |||
| logical(kind=lk), | intent(in) | :: | wantq | |||
| logical(kind=lk), | intent(in) | :: | wantz | |||
| logical(kind=lk), | intent(in) | :: | select(*) | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=dp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| complex(kind=dp), | intent(out) | :: | alpha(*) | |||
| complex(kind=dp), | intent(out) | :: | beta(*) | |||
| complex(kind=dp), | intent(inout) | :: | q(ldq,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldq | |||
| complex(kind=dp), | intent(inout) | :: | z(ldz,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldz | |||
| integer(kind=ilp), | intent(out) | :: | m | |||
| real(kind=dp), | intent(out) | :: | pl | |||
| real(kind=dp), | intent(out) | :: | pr | |||
| real(kind=dp), | intent(out) | :: | dif(*) | |||
| complex(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | iwork(*) | |||
| integer(kind=ilp), | intent(in) | :: | liwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
TGSJA computes the generalized singular value decomposition (GSVD) of two complex upper triangular (or trapezoidal) matrices A and B. On entry, it is assumed that matrices A and B have the following forms, which may be obtained by the preprocessing subroutine CGGSVP from a general M-by-N matrix A and P-by-N matrix B: N-K-L K L A = K ( 0 A12 A13 ) if M-K-L >= 0; L ( 0 0 A23 ) M-K-L ( 0 0 0 ) N-K-L K L A = K ( 0 A12 A13 ) if M-K-L < 0; M-K ( 0 0 A23 ) N-K-L K L B = L ( 0 0 B13 ) P-L ( 0 0 0 ) where the K-by-K matrix A12 and L-by-L matrix B13 are nonsingular upper triangular; A23 is L-by-L upper triangular if M-K-L >= 0, otherwise A23 is (M-K)-by-L upper trapezoidal. On exit, UH AQ = D1*( 0 R ), VH BQ = D2( 0 R ), where U, V and Q are unitary matrices. R is a nonsingular upper triangular matrix, and D1 and D2 are ``diagonal'' matrices, which are of the following structures: If M-K-L >= 0, K L D1 = K ( I 0 ) L ( 0 C ) M-K-L ( 0 0 ) K L D2 = L ( 0 S ) P-L ( 0 0 ) N-K-L K L ( 0 R ) = K ( 0 R11 R12 ) K L ( 0 0 R22 ) L where C = diag( ALPHA(K+1), ... , ALPHA(K+L) ), S = diag( BETA(K+1), ... , BETA(K+L) ), C2 + S2 = I. R is stored in A(1:K+L,N-K-L+1:N) on exit. If M-K-L < 0, K M-K K+L-M D1 = K ( I 0 0 ) M-K ( 0 C 0 ) K M-K K+L-M D2 = M-K ( 0 S 0 ) K+L-M ( 0 0 I ) P-L ( 0 0 0 ) N-K-L K M-K K+L-M ( 0 R ) = K ( 0 R11 R12 R13 ) M-K ( 0 0 R22 R23 ) K+L-M ( 0 0 0 R33 ) where C = diag( ALPHA(K+1), ... , ALPHA(M) ), S = diag( BETA(K+1), ... , BETA(M) ), C2 + S*2 = I. R = ( R11 R12 R13 ) is stored in A(1:M, N-K-L+1:N) and R33 is stored ( 0 R22 R23 ) in B(M-K+1:L,N+M-K-L+1:N) on exit. The computation of the unitary transformation matrices U, V or Q is optional. These matrices may either be formed explicitly, or they may be postmultiplied into input matrices U1, V1, or Q1.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | jobu | |||
| character, | intent(in) | :: | jobv | |||
| character, | intent(in) | :: | jobq | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | p | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | k | |||
| integer(kind=ilp), | intent(in) | :: | l | |||
| complex(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=sp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| real(kind=sp), | intent(in) | :: | tola | |||
| real(kind=sp), | intent(in) | :: | tolb | |||
| real(kind=sp), | intent(out) | :: | alpha(*) | |||
| real(kind=sp), | intent(out) | :: | beta(*) | |||
| complex(kind=sp), | intent(inout) | :: | u(ldu,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldu | |||
| complex(kind=sp), | intent(inout) | :: | v(ldv,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldv | |||
| complex(kind=sp), | intent(inout) | :: | q(ldq,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldq | |||
| complex(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | ncycle | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | jobu | |||
| character, | intent(in) | :: | jobv | |||
| character, | intent(in) | :: | jobq | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | p | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | k | |||
| integer(kind=ilp), | intent(in) | :: | l | |||
| real(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=dp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| real(kind=dp), | intent(in) | :: | tola | |||
| real(kind=dp), | intent(in) | :: | tolb | |||
| real(kind=dp), | intent(out) | :: | alpha(*) | |||
| real(kind=dp), | intent(out) | :: | beta(*) | |||
| real(kind=dp), | intent(inout) | :: | u(ldu,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldu | |||
| real(kind=dp), | intent(inout) | :: | v(ldv,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldv | |||
| real(kind=dp), | intent(inout) | :: | q(ldq,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldq | |||
| real(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | ncycle | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | jobu | |||
| character, | intent(in) | :: | jobv | |||
| character, | intent(in) | :: | jobq | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | p | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | k | |||
| integer(kind=ilp), | intent(in) | :: | l | |||
| real(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=sp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| real(kind=sp), | intent(in) | :: | tola | |||
| real(kind=sp), | intent(in) | :: | tolb | |||
| real(kind=sp), | intent(out) | :: | alpha(*) | |||
| real(kind=sp), | intent(out) | :: | beta(*) | |||
| real(kind=sp), | intent(inout) | :: | u(ldu,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldu | |||
| real(kind=sp), | intent(inout) | :: | v(ldv,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldv | |||
| real(kind=sp), | intent(inout) | :: | q(ldq,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldq | |||
| real(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | ncycle | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | jobu | |||
| character, | intent(in) | :: | jobv | |||
| character, | intent(in) | :: | jobq | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | p | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | k | |||
| integer(kind=ilp), | intent(in) | :: | l | |||
| complex(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=dp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| real(kind=dp), | intent(in) | :: | tola | |||
| real(kind=dp), | intent(in) | :: | tolb | |||
| real(kind=dp), | intent(out) | :: | alpha(*) | |||
| real(kind=dp), | intent(out) | :: | beta(*) | |||
| complex(kind=dp), | intent(inout) | :: | u(ldu,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldu | |||
| complex(kind=dp), | intent(inout) | :: | v(ldv,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldv | |||
| complex(kind=dp), | intent(inout) | :: | q(ldq,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldq | |||
| complex(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | ncycle | |||
| integer(kind=ilp), | intent(out) | :: | info |
CTGSJA computes the generalized singular value decomposition (GSVD) of two complex upper triangular (or trapezoidal) matrices A and B. On entry, it is assumed that matrices A and B have the following forms, which may be obtained by the preprocessing subroutine CGGSVP from a general M-by-N matrix A and P-by-N matrix B: N-K-L K L A = K ( 0 A12 A13 ) if M-K-L >= 0; L ( 0 0 A23 ) M-K-L ( 0 0 0 ) N-K-L K L A = K ( 0 A12 A13 ) if M-K-L < 0; M-K ( 0 0 A23 ) N-K-L K L B = L ( 0 0 B13 ) P-L ( 0 0 0 ) where the K-by-K matrix A12 and L-by-L matrix B13 are nonsingular upper triangular; A23 is L-by-L upper triangular if M-K-L >= 0, otherwise A23 is (M-K)-by-L upper trapezoidal. On exit, UH AQ = D1*( 0 R ), VH BQ = D2( 0 R ), where U, V and Q are unitary matrices. R is a nonsingular upper triangular matrix, and D1 and D2 are ``diagonal'' matrices, which are of the following structures: If M-K-L >= 0, K L D1 = K ( I 0 ) L ( 0 C ) M-K-L ( 0 0 ) K L D2 = L ( 0 S ) P-L ( 0 0 ) N-K-L K L ( 0 R ) = K ( 0 R11 R12 ) K L ( 0 0 R22 ) L where C = diag( ALPHA(K+1), ... , ALPHA(K+L) ), S = diag( BETA(K+1), ... , BETA(K+L) ), C2 + S2 = I. R is stored in A(1:K+L,N-K-L+1:N) on exit. If M-K-L < 0, K M-K K+L-M D1 = K ( I 0 0 ) M-K ( 0 C 0 ) K M-K K+L-M D2 = M-K ( 0 S 0 ) K+L-M ( 0 0 I ) P-L ( 0 0 0 ) N-K-L K M-K K+L-M ( 0 R ) = K ( 0 R11 R12 R13 ) M-K ( 0 0 R22 R23 ) K+L-M ( 0 0 0 R33 ) where C = diag( ALPHA(K+1), ... , ALPHA(M) ), S = diag( BETA(K+1), ... , BETA(M) ), C2 + S*2 = I. R = ( R11 R12 R13 ) is stored in A(1:M, N-K-L+1:N) and R33 is stored ( 0 R22 R23 ) in B(M-K+1:L,N+M-K-L+1:N) on exit. The computation of the unitary transformation matrices U, V or Q is optional. These matrices may either be formed explicitly, or they may be postmultiplied into input matrices U1, V1, or Q1.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | jobu | |||
| character, | intent(in) | :: | jobv | |||
| character, | intent(in) | :: | jobq | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | p | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | k | |||
| integer(kind=ilp), | intent(in) | :: | l | |||
| complex(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=sp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| real(kind=sp), | intent(in) | :: | tola | |||
| real(kind=sp), | intent(in) | :: | tolb | |||
| real(kind=sp), | intent(out) | :: | alpha(*) | |||
| real(kind=sp), | intent(out) | :: | beta(*) | |||
| complex(kind=sp), | intent(inout) | :: | u(ldu,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldu | |||
| complex(kind=sp), | intent(inout) | :: | v(ldv,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldv | |||
| complex(kind=sp), | intent(inout) | :: | q(ldq,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldq | |||
| complex(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | ncycle | |||
| integer(kind=ilp), | intent(out) | :: | info |
DTGSJA computes the generalized singular value decomposition (GSVD) of two real upper triangular (or trapezoidal) matrices A and B. On entry, it is assumed that matrices A and B have the following forms, which may be obtained by the preprocessing subroutine DGGSVP from a general M-by-N matrix A and P-by-N matrix B: N-K-L K L A = K ( 0 A12 A13 ) if M-K-L >= 0; L ( 0 0 A23 ) M-K-L ( 0 0 0 ) N-K-L K L A = K ( 0 A12 A13 ) if M-K-L < 0; M-K ( 0 0 A23 ) N-K-L K L B = L ( 0 0 B13 ) P-L ( 0 0 0 ) where the K-by-K matrix A12 and L-by-L matrix B13 are nonsingular upper triangular; A23 is L-by-L upper triangular if M-K-L >= 0, otherwise A23 is (M-K)-by-L upper trapezoidal. On exit, UT AQ = D1*( 0 R ), VT BQ = D2( 0 R ), where U, V and Q are orthogonal matrices. R is a nonsingular upper triangular matrix, and D1 and D2 are ``diagonal'' matrices, which are of the following structures: If M-K-L >= 0, K L D1 = K ( I 0 ) L ( 0 C ) M-K-L ( 0 0 ) K L D2 = L ( 0 S ) P-L ( 0 0 ) N-K-L K L ( 0 R ) = K ( 0 R11 R12 ) K L ( 0 0 R22 ) L where C = diag( ALPHA(K+1), ... , ALPHA(K+L) ), S = diag( BETA(K+1), ... , BETA(K+L) ), C2 + S2 = I. R is stored in A(1:K+L,N-K-L+1:N) on exit. If M-K-L < 0, K M-K K+L-M D1 = K ( I 0 0 ) M-K ( 0 C 0 ) K M-K K+L-M D2 = M-K ( 0 S 0 ) K+L-M ( 0 0 I ) P-L ( 0 0 0 ) N-K-L K M-K K+L-M ( 0 R ) = K ( 0 R11 R12 R13 ) M-K ( 0 0 R22 R23 ) K+L-M ( 0 0 0 R33 ) where C = diag( ALPHA(K+1), ... , ALPHA(M) ), S = diag( BETA(K+1), ... , BETA(M) ), C2 + S*2 = I. R = ( R11 R12 R13 ) is stored in A(1:M, N-K-L+1:N) and R33 is stored ( 0 R22 R23 ) in B(M-K+1:L,N+M-K-L+1:N) on exit. The computation of the orthogonal transformation matrices U, V or Q is optional. These matrices may either be formed explicitly, or they may be postmultiplied into input matrices U1, V1, or Q1.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | jobu | |||
| character, | intent(in) | :: | jobv | |||
| character, | intent(in) | :: | jobq | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | p | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | k | |||
| integer(kind=ilp), | intent(in) | :: | l | |||
| real(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=dp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| real(kind=dp), | intent(in) | :: | tola | |||
| real(kind=dp), | intent(in) | :: | tolb | |||
| real(kind=dp), | intent(out) | :: | alpha(*) | |||
| real(kind=dp), | intent(out) | :: | beta(*) | |||
| real(kind=dp), | intent(inout) | :: | u(ldu,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldu | |||
| real(kind=dp), | intent(inout) | :: | v(ldv,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldv | |||
| real(kind=dp), | intent(inout) | :: | q(ldq,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldq | |||
| real(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | ncycle | |||
| integer(kind=ilp), | intent(out) | :: | info |
STGSJA computes the generalized singular value decomposition (GSVD) of two real upper triangular (or trapezoidal) matrices A and B. On entry, it is assumed that matrices A and B have the following forms, which may be obtained by the preprocessing subroutine SGGSVP from a general M-by-N matrix A and P-by-N matrix B: N-K-L K L A = K ( 0 A12 A13 ) if M-K-L >= 0; L ( 0 0 A23 ) M-K-L ( 0 0 0 ) N-K-L K L A = K ( 0 A12 A13 ) if M-K-L < 0; M-K ( 0 0 A23 ) N-K-L K L B = L ( 0 0 B13 ) P-L ( 0 0 0 ) where the K-by-K matrix A12 and L-by-L matrix B13 are nonsingular upper triangular; A23 is L-by-L upper triangular if M-K-L >= 0, otherwise A23 is (M-K)-by-L upper trapezoidal. On exit, UT AQ = D1*( 0 R ), VT BQ = D2( 0 R ), where U, V and Q are orthogonal matrices. R is a nonsingular upper triangular matrix, and D1 and D2 are ``diagonal'' matrices, which are of the following structures: If M-K-L >= 0, K L D1 = K ( I 0 ) L ( 0 C ) M-K-L ( 0 0 ) K L D2 = L ( 0 S ) P-L ( 0 0 ) N-K-L K L ( 0 R ) = K ( 0 R11 R12 ) K L ( 0 0 R22 ) L where C = diag( ALPHA(K+1), ... , ALPHA(K+L) ), S = diag( BETA(K+1), ... , BETA(K+L) ), C2 + S2 = I. R is stored in A(1:K+L,N-K-L+1:N) on exit. If M-K-L < 0, K M-K K+L-M D1 = K ( I 0 0 ) M-K ( 0 C 0 ) K M-K K+L-M D2 = M-K ( 0 S 0 ) K+L-M ( 0 0 I ) P-L ( 0 0 0 ) N-K-L K M-K K+L-M ( 0 R ) = K ( 0 R11 R12 R13 ) M-K ( 0 0 R22 R23 ) K+L-M ( 0 0 0 R33 ) where C = diag( ALPHA(K+1), ... , ALPHA(M) ), S = diag( BETA(K+1), ... , BETA(M) ), C2 + S*2 = I. R = ( R11 R12 R13 ) is stored in A(1:M, N-K-L+1:N) and R33 is stored ( 0 R22 R23 ) in B(M-K+1:L,N+M-K-L+1:N) on exit. The computation of the orthogonal transformation matrices U, V or Q is optional. These matrices may either be formed explicitly, or they may be postmultiplied into input matrices U1, V1, or Q1.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | jobu | |||
| character, | intent(in) | :: | jobv | |||
| character, | intent(in) | :: | jobq | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | p | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | k | |||
| integer(kind=ilp), | intent(in) | :: | l | |||
| real(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=sp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| real(kind=sp), | intent(in) | :: | tola | |||
| real(kind=sp), | intent(in) | :: | tolb | |||
| real(kind=sp), | intent(out) | :: | alpha(*) | |||
| real(kind=sp), | intent(out) | :: | beta(*) | |||
| real(kind=sp), | intent(inout) | :: | u(ldu,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldu | |||
| real(kind=sp), | intent(inout) | :: | v(ldv,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldv | |||
| real(kind=sp), | intent(inout) | :: | q(ldq,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldq | |||
| real(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | ncycle | |||
| integer(kind=ilp), | intent(out) | :: | info |
ZTGSJA computes the generalized singular value decomposition (GSVD) of two complex upper triangular (or trapezoidal) matrices A and B. On entry, it is assumed that matrices A and B have the following forms, which may be obtained by the preprocessing subroutine ZGGSVP from a general M-by-N matrix A and P-by-N matrix B: N-K-L K L A = K ( 0 A12 A13 ) if M-K-L >= 0; L ( 0 0 A23 ) M-K-L ( 0 0 0 ) N-K-L K L A = K ( 0 A12 A13 ) if M-K-L < 0; M-K ( 0 0 A23 ) N-K-L K L B = L ( 0 0 B13 ) P-L ( 0 0 0 ) where the K-by-K matrix A12 and L-by-L matrix B13 are nonsingular upper triangular; A23 is L-by-L upper triangular if M-K-L >= 0, otherwise A23 is (M-K)-by-L upper trapezoidal. On exit, UH AQ = D1*( 0 R ), VH BQ = D2( 0 R ), where U, V and Q are unitary matrices. R is a nonsingular upper triangular matrix, and D1 and D2 are ``diagonal'' matrices, which are of the following structures: If M-K-L >= 0, K L D1 = K ( I 0 ) L ( 0 C ) M-K-L ( 0 0 ) K L D2 = L ( 0 S ) P-L ( 0 0 ) N-K-L K L ( 0 R ) = K ( 0 R11 R12 ) K L ( 0 0 R22 ) L where C = diag( ALPHA(K+1), ... , ALPHA(K+L) ), S = diag( BETA(K+1), ... , BETA(K+L) ), C2 + S2 = I. R is stored in A(1:K+L,N-K-L+1:N) on exit. If M-K-L < 0, K M-K K+L-M D1 = K ( I 0 0 ) M-K ( 0 C 0 ) K M-K K+L-M D2 = M-K ( 0 S 0 ) K+L-M ( 0 0 I ) P-L ( 0 0 0 ) N-K-L K M-K K+L-M ( 0 R ) = K ( 0 R11 R12 R13 ) M-K ( 0 0 R22 R23 ) K+L-M ( 0 0 0 R33 ) where C = diag( ALPHA(K+1), ... , ALPHA(M) ), S = diag( BETA(K+1), ... , BETA(M) ), C2 + S*2 = I. R = ( R11 R12 R13 ) is stored in A(1:M, N-K-L+1:N) and R33 is stored ( 0 R22 R23 ) in B(M-K+1:L,N+M-K-L+1:N) on exit. The computation of the unitary transformation matrices U, V or Q is optional. These matrices may either be formed explicitly, or they may be postmultiplied into input matrices U1, V1, or Q1.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | jobu | |||
| character, | intent(in) | :: | jobv | |||
| character, | intent(in) | :: | jobq | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | p | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | k | |||
| integer(kind=ilp), | intent(in) | :: | l | |||
| complex(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=dp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| real(kind=dp), | intent(in) | :: | tola | |||
| real(kind=dp), | intent(in) | :: | tolb | |||
| real(kind=dp), | intent(out) | :: | alpha(*) | |||
| real(kind=dp), | intent(out) | :: | beta(*) | |||
| complex(kind=dp), | intent(inout) | :: | u(ldu,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldu | |||
| complex(kind=dp), | intent(inout) | :: | v(ldv,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldv | |||
| complex(kind=dp), | intent(inout) | :: | q(ldq,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldq | |||
| complex(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | ncycle | |||
| integer(kind=ilp), | intent(out) | :: | info |
TGSNA estimates reciprocal condition numbers for specified eigenvalues and/or eigenvectors of a matrix pair (A, B). (A, B) must be in generalized Schur canonical form, that is, A and B are both upper triangular.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | job | |||
| character, | intent(in) | :: | howmny | |||
| logical(kind=lk), | intent(in) | :: | select(*) | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=sp), | intent(in) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=sp), | intent(in) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| complex(kind=sp), | intent(in) | :: | vl(ldvl,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldvl | |||
| complex(kind=sp), | intent(in) | :: | vr(ldvr,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldvr | |||
| real(kind=sp), | intent(out) | :: | s(*) | |||
| real(kind=sp), | intent(out) | :: | dif(*) | |||
| integer(kind=ilp), | intent(in) | :: | mm | |||
| integer(kind=ilp), | intent(out) | :: | m | |||
| complex(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | iwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | job | |||
| character, | intent(in) | :: | howmny | |||
| logical(kind=lk), | intent(in) | :: | select(*) | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=dp), | intent(in) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=dp), | intent(in) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| real(kind=dp), | intent(in) | :: | vl(ldvl,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldvl | |||
| real(kind=dp), | intent(in) | :: | vr(ldvr,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldvr | |||
| real(kind=dp), | intent(out) | :: | s(*) | |||
| real(kind=dp), | intent(out) | :: | dif(*) | |||
| integer(kind=ilp), | intent(in) | :: | mm | |||
| integer(kind=ilp), | intent(out) | :: | m | |||
| real(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | iwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | job | |||
| character, | intent(in) | :: | howmny | |||
| logical(kind=lk), | intent(in) | :: | select(*) | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=sp), | intent(in) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=sp), | intent(in) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| real(kind=sp), | intent(in) | :: | vl(ldvl,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldvl | |||
| real(kind=sp), | intent(in) | :: | vr(ldvr,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldvr | |||
| real(kind=sp), | intent(out) | :: | s(*) | |||
| real(kind=sp), | intent(out) | :: | dif(*) | |||
| integer(kind=ilp), | intent(in) | :: | mm | |||
| integer(kind=ilp), | intent(out) | :: | m | |||
| real(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | iwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | job | |||
| character, | intent(in) | :: | howmny | |||
| logical(kind=lk), | intent(in) | :: | select(*) | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=dp), | intent(in) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=dp), | intent(in) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| complex(kind=dp), | intent(in) | :: | vl(ldvl,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldvl | |||
| complex(kind=dp), | intent(in) | :: | vr(ldvr,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldvr | |||
| real(kind=dp), | intent(out) | :: | s(*) | |||
| real(kind=dp), | intent(out) | :: | dif(*) | |||
| integer(kind=ilp), | intent(in) | :: | mm | |||
| integer(kind=ilp), | intent(out) | :: | m | |||
| complex(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | iwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
CTGSNA estimates reciprocal condition numbers for specified eigenvalues and/or eigenvectors of a matrix pair (A, B). (A, B) must be in generalized Schur canonical form, that is, A and B are both upper triangular.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | job | |||
| character, | intent(in) | :: | howmny | |||
| logical(kind=lk), | intent(in) | :: | select(*) | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=sp), | intent(in) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=sp), | intent(in) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| complex(kind=sp), | intent(in) | :: | vl(ldvl,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldvl | |||
| complex(kind=sp), | intent(in) | :: | vr(ldvr,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldvr | |||
| real(kind=sp), | intent(out) | :: | s(*) | |||
| real(kind=sp), | intent(out) | :: | dif(*) | |||
| integer(kind=ilp), | intent(in) | :: | mm | |||
| integer(kind=ilp), | intent(out) | :: | m | |||
| complex(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | iwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
DTGSNA estimates reciprocal condition numbers for specified eigenvalues and/or eigenvectors of a matrix pair (A, B) in generalized real Schur canonical form (or of any matrix pair (QAZT, QBZT) with orthogonal matrices Q and Z, where Z**T denotes the transpose of Z. (A, B) must be in generalized real Schur form (as returned by DGGES), i.e. A is block upper triangular with 1-by-1 and 2-by-2 diagonal blocks. B is upper triangular.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | job | |||
| character, | intent(in) | :: | howmny | |||
| logical(kind=lk), | intent(in) | :: | select(*) | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=dp), | intent(in) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=dp), | intent(in) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| real(kind=dp), | intent(in) | :: | vl(ldvl,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldvl | |||
| real(kind=dp), | intent(in) | :: | vr(ldvr,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldvr | |||
| real(kind=dp), | intent(out) | :: | s(*) | |||
| real(kind=dp), | intent(out) | :: | dif(*) | |||
| integer(kind=ilp), | intent(in) | :: | mm | |||
| integer(kind=ilp), | intent(out) | :: | m | |||
| real(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | iwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
STGSNA estimates reciprocal condition numbers for specified eigenvalues and/or eigenvectors of a matrix pair (A, B) in generalized real Schur canonical form (or of any matrix pair (QAZT, QBZT) with orthogonal matrices Q and Z, where Z**T denotes the transpose of Z. (A, B) must be in generalized real Schur form (as returned by SGGES), i.e. A is block upper triangular with 1-by-1 and 2-by-2 diagonal blocks. B is upper triangular.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | job | |||
| character, | intent(in) | :: | howmny | |||
| logical(kind=lk), | intent(in) | :: | select(*) | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=sp), | intent(in) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=sp), | intent(in) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| real(kind=sp), | intent(in) | :: | vl(ldvl,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldvl | |||
| real(kind=sp), | intent(in) | :: | vr(ldvr,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldvr | |||
| real(kind=sp), | intent(out) | :: | s(*) | |||
| real(kind=sp), | intent(out) | :: | dif(*) | |||
| integer(kind=ilp), | intent(in) | :: | mm | |||
| integer(kind=ilp), | intent(out) | :: | m | |||
| real(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | iwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
ZTGSNA estimates reciprocal condition numbers for specified eigenvalues and/or eigenvectors of a matrix pair (A, B). (A, B) must be in generalized Schur canonical form, that is, A and B are both upper triangular.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | job | |||
| character, | intent(in) | :: | howmny | |||
| logical(kind=lk), | intent(in) | :: | select(*) | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=dp), | intent(in) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=dp), | intent(in) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| complex(kind=dp), | intent(in) | :: | vl(ldvl,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldvl | |||
| complex(kind=dp), | intent(in) | :: | vr(ldvr,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldvr | |||
| real(kind=dp), | intent(out) | :: | s(*) | |||
| real(kind=dp), | intent(out) | :: | dif(*) | |||
| integer(kind=ilp), | intent(in) | :: | mm | |||
| integer(kind=ilp), | intent(out) | :: | m | |||
| complex(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | iwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
TGSYL solves the generalized Sylvester equation: A * R - L * B = scale * C (1) D * R - L * E = scale * F where R and L are unknown m-by-n matrices, (A, D), (B, E) and (C, F) are given matrix pairs of size m-by-m, n-by-n and m-by-n, respectively, with complex entries. A, B, D and E are upper triangular (i.e., (A,D) and (B,E) in generalized Schur form). The solution (R, L) overwrites (C, F). 0 <= SCALE <= 1 is an output scaling factor chosen to avoid overflow. In matrix notation (1) is equivalent to solve Zx = scaleb, where Z is defined as Z = [ kron(In, A) -kron(BH, Im) ] (2) [ kron(In, D) -kron(EH, Im) ], Here Ix is the identity matrix of size x and XH is the conjugate transpose of X. Kron(X, Y) is the Kronecker product between the matrices X and Y. If TRANS = 'C', y in the conjugate transposed system ZH y = scaleb is solved for, which is equivalent to solve for R and L in AH * R + DH * L = scale * C (3) R * BH + L * E*H = scale * -F This case (TRANS = 'C') is used to compute an one-norm-based estimate of Dif[(A,D), (B,E)], the separation between the matrix pairs (A,D) and (B,E), using CLACON. If IJOB >= 1, TGSYL computes a Frobenius norm-based estimate of Dif[(A,D),(B,E)]. That is, the reciprocal of a lower bound on the reciprocal of the smallest singular value of Z. This is a level-3 BLAS algorithm.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | trans | |||
| integer(kind=ilp), | intent(in) | :: | ijob | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=sp), | intent(in) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=sp), | intent(in) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| complex(kind=sp), | intent(inout) | :: | c(ldc,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldc | |||
| complex(kind=sp), | intent(in) | :: | d(ldd,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldd | |||
| complex(kind=sp), | intent(in) | :: | e(lde,*) | |||
| integer(kind=ilp), | intent(in) | :: | lde | |||
| complex(kind=sp), | intent(inout) | :: | f(ldf,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldf | |||
| real(kind=sp), | intent(out) | :: | scale | |||
| real(kind=sp), | intent(out) | :: | dif | |||
| complex(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | iwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | trans | |||
| integer(kind=ilp), | intent(in) | :: | ijob | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=dp), | intent(in) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=dp), | intent(in) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| real(kind=dp), | intent(inout) | :: | c(ldc,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldc | |||
| real(kind=dp), | intent(in) | :: | d(ldd,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldd | |||
| real(kind=dp), | intent(in) | :: | e(lde,*) | |||
| integer(kind=ilp), | intent(in) | :: | lde | |||
| real(kind=dp), | intent(inout) | :: | f(ldf,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldf | |||
| real(kind=dp), | intent(out) | :: | scale | |||
| real(kind=dp), | intent(out) | :: | dif | |||
| real(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | iwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | trans | |||
| integer(kind=ilp), | intent(in) | :: | ijob | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=sp), | intent(in) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=sp), | intent(in) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| real(kind=sp), | intent(inout) | :: | c(ldc,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldc | |||
| real(kind=sp), | intent(in) | :: | d(ldd,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldd | |||
| real(kind=sp), | intent(in) | :: | e(lde,*) | |||
| integer(kind=ilp), | intent(in) | :: | lde | |||
| real(kind=sp), | intent(inout) | :: | f(ldf,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldf | |||
| real(kind=sp), | intent(out) | :: | scale | |||
| real(kind=sp), | intent(out) | :: | dif | |||
| real(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | iwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | trans | |||
| integer(kind=ilp), | intent(in) | :: | ijob | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=dp), | intent(in) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=dp), | intent(in) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| complex(kind=dp), | intent(inout) | :: | c(ldc,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldc | |||
| complex(kind=dp), | intent(in) | :: | d(ldd,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldd | |||
| complex(kind=dp), | intent(in) | :: | e(lde,*) | |||
| integer(kind=ilp), | intent(in) | :: | lde | |||
| complex(kind=dp), | intent(inout) | :: | f(ldf,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldf | |||
| real(kind=dp), | intent(out) | :: | scale | |||
| real(kind=dp), | intent(out) | :: | dif | |||
| complex(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | iwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
CTGSYL solves the generalized Sylvester equation: A * R - L * B = scale * C (1) D * R - L * E = scale * F where R and L are unknown m-by-n matrices, (A, D), (B, E) and (C, F) are given matrix pairs of size m-by-m, n-by-n and m-by-n, respectively, with complex entries. A, B, D and E are upper triangular (i.e., (A,D) and (B,E) in generalized Schur form). The solution (R, L) overwrites (C, F). 0 <= SCALE <= 1 is an output scaling factor chosen to avoid overflow. In matrix notation (1) is equivalent to solve Zx = scaleb, where Z is defined as Z = [ kron(In, A) -kron(BH, Im) ] (2) [ kron(In, D) -kron(EH, Im) ], Here Ix is the identity matrix of size x and XH is the conjugate transpose of X. Kron(X, Y) is the Kronecker product between the matrices X and Y. If TRANS = 'C', y in the conjugate transposed system ZH y = scaleb is solved for, which is equivalent to solve for R and L in AH * R + DH * L = scale * C (3) R * BH + L * E*H = scale * -F This case (TRANS = 'C') is used to compute an one-norm-based estimate of Dif[(A,D), (B,E)], the separation between the matrix pairs (A,D) and (B,E), using CLACON. If IJOB >= 1, CTGSYL computes a Frobenius norm-based estimate of Dif[(A,D),(B,E)]. That is, the reciprocal of a lower bound on the reciprocal of the smallest singular value of Z. This is a level-3 BLAS algorithm.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | trans | |||
| integer(kind=ilp), | intent(in) | :: | ijob | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=sp), | intent(in) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=sp), | intent(in) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| complex(kind=sp), | intent(inout) | :: | c(ldc,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldc | |||
| complex(kind=sp), | intent(in) | :: | d(ldd,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldd | |||
| complex(kind=sp), | intent(in) | :: | e(lde,*) | |||
| integer(kind=ilp), | intent(in) | :: | lde | |||
| complex(kind=sp), | intent(inout) | :: | f(ldf,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldf | |||
| real(kind=sp), | intent(out) | :: | scale | |||
| real(kind=sp), | intent(out) | :: | dif | |||
| complex(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | iwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
DTGSYL solves the generalized Sylvester equation: A * R - L * B = scale * C (1) D * R - L * E = scale * F where R and L are unknown m-by-n matrices, (A, D), (B, E) and (C, F) are given matrix pairs of size m-by-m, n-by-n and m-by-n, respectively, with real entries. (A, D) and (B, E) must be in generalized (real) Schur canonical form, i.e. A, B are upper quasi triangular and D, E are upper triangular. The solution (R, L) overwrites (C, F). 0 <= SCALE <= 1 is an output scaling factor chosen to avoid overflow. In matrix notation (1) is equivalent to solve Zx = scale b, where Z is defined as Z = [ kron(In, A) -kron(BT, Im) ] (2) [ kron(In, D) -kron(ET, Im) ]. Here Ik is the identity matrix of size k and XT is the transpose of X. kron(X, Y) is the Kronecker product between the matrices X and Y. If TRANS = 'T', DTGSYL solves the transposed system ZTy = scaleb, which is equivalent to solve for R and L in AT * R + DT * L = scale * C (3) R * BT + L * ET = scale * -F This case (TRANS = 'T') is used to compute an one-norm-based estimate of Dif[(A,D), (B,E)], the separation between the matrix pairs (A,D) and (B,E), using DLACON. If IJOB >= 1, DTGSYL computes a Frobenius norm-based estimate of Dif[(A,D),(B,E)]. That is, the reciprocal of a lower bound on the reciprocal of the smallest singular value of Z. See [1-2] for more information. This is a level 3 BLAS algorithm.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | trans | |||
| integer(kind=ilp), | intent(in) | :: | ijob | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=dp), | intent(in) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=dp), | intent(in) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| real(kind=dp), | intent(inout) | :: | c(ldc,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldc | |||
| real(kind=dp), | intent(in) | :: | d(ldd,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldd | |||
| real(kind=dp), | intent(in) | :: | e(lde,*) | |||
| integer(kind=ilp), | intent(in) | :: | lde | |||
| real(kind=dp), | intent(inout) | :: | f(ldf,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldf | |||
| real(kind=dp), | intent(out) | :: | scale | |||
| real(kind=dp), | intent(out) | :: | dif | |||
| real(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | iwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
STGSYL solves the generalized Sylvester equation: A * R - L * B = scale * C (1) D * R - L * E = scale * F where R and L are unknown m-by-n matrices, (A, D), (B, E) and (C, F) are given matrix pairs of size m-by-m, n-by-n and m-by-n, respectively, with real entries. (A, D) and (B, E) must be in generalized (real) Schur canonical form, i.e. A, B are upper quasi triangular and D, E are upper triangular. The solution (R, L) overwrites (C, F). 0 <= SCALE <= 1 is an output scaling factor chosen to avoid overflow. In matrix notation (1) is equivalent to solve Zx = scale b, where Z is defined as Z = [ kron(In, A) -kron(BT, Im) ] (2) [ kron(In, D) -kron(ET, Im) ]. Here Ik is the identity matrix of size k and XT is the transpose of X. kron(X, Y) is the Kronecker product between the matrices X and Y. If TRANS = 'T', STGSYL solves the transposed system ZTy = scaleb, which is equivalent to solve for R and L in AT * R + DT * L = scale * C (3) R * BT + L * ET = scale * -F This case (TRANS = 'T') is used to compute an one-norm-based estimate of Dif[(A,D), (B,E)], the separation between the matrix pairs (A,D) and (B,E), using SLACON. If IJOB >= 1, STGSYL computes a Frobenius norm-based estimate of Dif[(A,D),(B,E)]. That is, the reciprocal of a lower bound on the reciprocal of the smallest singular value of Z. See [1-2] for more information. This is a level 3 BLAS algorithm.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | trans | |||
| integer(kind=ilp), | intent(in) | :: | ijob | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=sp), | intent(in) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=sp), | intent(in) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| real(kind=sp), | intent(inout) | :: | c(ldc,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldc | |||
| real(kind=sp), | intent(in) | :: | d(ldd,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldd | |||
| real(kind=sp), | intent(in) | :: | e(lde,*) | |||
| integer(kind=ilp), | intent(in) | :: | lde | |||
| real(kind=sp), | intent(inout) | :: | f(ldf,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldf | |||
| real(kind=sp), | intent(out) | :: | scale | |||
| real(kind=sp), | intent(out) | :: | dif | |||
| real(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | iwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
ZTGSYL solves the generalized Sylvester equation: A * R - L * B = scale * C (1) D * R - L * E = scale * F where R and L are unknown m-by-n matrices, (A, D), (B, E) and (C, F) are given matrix pairs of size m-by-m, n-by-n and m-by-n, respectively, with complex entries. A, B, D and E are upper triangular (i.e., (A,D) and (B,E) in generalized Schur form). The solution (R, L) overwrites (C, F). 0 <= SCALE <= 1 is an output scaling factor chosen to avoid overflow. In matrix notation (1) is equivalent to solve Zx = scaleb, where Z is defined as Z = [ kron(In, A) -kron(BH, Im) ] (2) [ kron(In, D) -kron(EH, Im) ], Here Ix is the identity matrix of size x and XH is the conjugate transpose of X. Kron(X, Y) is the Kronecker product between the matrices X and Y. If TRANS = 'C', y in the conjugate transposed system ZH y = scaleb is solved for, which is equivalent to solve for R and L in AH * R + DH * L = scale * C (3) R * BH + L * E*H = scale * -F This case (TRANS = 'C') is used to compute an one-norm-based estimate of Dif[(A,D), (B,E)], the separation between the matrix pairs (A,D) and (B,E), using ZLACON. If IJOB >= 1, ZTGSYL computes a Frobenius norm-based estimate of Dif[(A,D),(B,E)]. That is, the reciprocal of a lower bound on the reciprocal of the smallest singular value of Z. This is a level-3 BLAS algorithm.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | trans | |||
| integer(kind=ilp), | intent(in) | :: | ijob | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=dp), | intent(in) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=dp), | intent(in) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| complex(kind=dp), | intent(inout) | :: | c(ldc,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldc | |||
| complex(kind=dp), | intent(in) | :: | d(ldd,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldd | |||
| complex(kind=dp), | intent(in) | :: | e(lde,*) | |||
| integer(kind=ilp), | intent(in) | :: | lde | |||
| complex(kind=dp), | intent(inout) | :: | f(ldf,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldf | |||
| real(kind=dp), | intent(out) | :: | scale | |||
| real(kind=dp), | intent(out) | :: | dif | |||
| complex(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | iwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
TPCON estimates the reciprocal of the condition number of a packed triangular matrix A, in either the 1-norm or the infinity-norm. The norm of A is computed and an estimate is obtained for norm(inv(A)), then the reciprocal of the condition number is computed as RCOND = 1 / ( norm(A) * norm(inv(A)) ).
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | norm | |||
| character, | intent(in) | :: | uplo | |||
| character, | intent(in) | :: | diag | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=sp), | intent(in) | :: | ap(*) | |||
| real(kind=sp), | intent(out) | :: | rcond | |||
| complex(kind=sp), | intent(out) | :: | work(*) | |||
| real(kind=sp), | intent(out) | :: | rwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | norm | |||
| character, | intent(in) | :: | uplo | |||
| character, | intent(in) | :: | diag | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=dp), | intent(in) | :: | ap(*) | |||
| real(kind=dp), | intent(out) | :: | rcond | |||
| real(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | iwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | norm | |||
| character, | intent(in) | :: | uplo | |||
| character, | intent(in) | :: | diag | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=sp), | intent(in) | :: | ap(*) | |||
| real(kind=sp), | intent(out) | :: | rcond | |||
| real(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | iwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | norm | |||
| character, | intent(in) | :: | uplo | |||
| character, | intent(in) | :: | diag | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=dp), | intent(in) | :: | ap(*) | |||
| real(kind=dp), | intent(out) | :: | rcond | |||
| complex(kind=dp), | intent(out) | :: | work(*) | |||
| real(kind=dp), | intent(out) | :: | rwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
CTPCON estimates the reciprocal of the condition number of a packed triangular matrix A, in either the 1-norm or the infinity-norm. The norm of A is computed and an estimate is obtained for norm(inv(A)), then the reciprocal of the condition number is computed as RCOND = 1 / ( norm(A) * norm(inv(A)) ).
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | norm | |||
| character, | intent(in) | :: | uplo | |||
| character, | intent(in) | :: | diag | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=sp), | intent(in) | :: | ap(*) | |||
| real(kind=sp), | intent(out) | :: | rcond | |||
| complex(kind=sp), | intent(out) | :: | work(*) | |||
| real(kind=sp), | intent(out) | :: | rwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
DTPCON estimates the reciprocal of the condition number of a packed triangular matrix A, in either the 1-norm or the infinity-norm. The norm of A is computed and an estimate is obtained for norm(inv(A)), then the reciprocal of the condition number is computed as RCOND = 1 / ( norm(A) * norm(inv(A)) ).
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | norm | |||
| character, | intent(in) | :: | uplo | |||
| character, | intent(in) | :: | diag | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=dp), | intent(in) | :: | ap(*) | |||
| real(kind=dp), | intent(out) | :: | rcond | |||
| real(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | iwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
STPCON estimates the reciprocal of the condition number of a packed triangular matrix A, in either the 1-norm or the infinity-norm. The norm of A is computed and an estimate is obtained for norm(inv(A)), then the reciprocal of the condition number is computed as RCOND = 1 / ( norm(A) * norm(inv(A)) ).
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | norm | |||
| character, | intent(in) | :: | uplo | |||
| character, | intent(in) | :: | diag | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=sp), | intent(in) | :: | ap(*) | |||
| real(kind=sp), | intent(out) | :: | rcond | |||
| real(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | iwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
ZTPCON estimates the reciprocal of the condition number of a packed triangular matrix A, in either the 1-norm or the infinity-norm. The norm of A is computed and an estimate is obtained for norm(inv(A)), then the reciprocal of the condition number is computed as RCOND = 1 / ( norm(A) * norm(inv(A)) ).
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | norm | |||
| character, | intent(in) | :: | uplo | |||
| character, | intent(in) | :: | diag | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=dp), | intent(in) | :: | ap(*) | |||
| real(kind=dp), | intent(out) | :: | rcond | |||
| complex(kind=dp), | intent(out) | :: | work(*) | |||
| real(kind=dp), | intent(out) | :: | rwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
TPLQT computes a blocked LQ factorization of a complex "triangular-pentagonal" matrix C, which is composed of a triangular block A and pentagonal block B, using the compact WY representation for Q.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | l | |||
| integer(kind=ilp), | intent(in) | :: | mb | |||
| complex(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=sp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| complex(kind=sp), | intent(out) | :: | t(ldt,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldt | |||
| complex(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | l | |||
| integer(kind=ilp), | intent(in) | :: | mb | |||
| real(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=dp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| real(kind=dp), | intent(out) | :: | t(ldt,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldt | |||
| real(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | l | |||
| integer(kind=ilp), | intent(in) | :: | mb | |||
| real(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=sp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| real(kind=sp), | intent(out) | :: | t(ldt,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldt | |||
| real(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | l | |||
| integer(kind=ilp), | intent(in) | :: | mb | |||
| complex(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=dp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| complex(kind=dp), | intent(out) | :: | t(ldt,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldt | |||
| complex(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
CTPLQT computes a blocked LQ factorization of a complex "triangular-pentagonal" matrix C, which is composed of a triangular block A and pentagonal block B, using the compact WY representation for Q.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | l | |||
| integer(kind=ilp), | intent(in) | :: | mb | |||
| complex(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=sp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| complex(kind=sp), | intent(out) | :: | t(ldt,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldt | |||
| complex(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
DTPLQT computes a blocked LQ factorization of a real "triangular-pentagonal" matrix C, which is composed of a triangular block A and pentagonal block B, using the compact WY representation for Q.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | l | |||
| integer(kind=ilp), | intent(in) | :: | mb | |||
| real(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=dp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| real(kind=dp), | intent(out) | :: | t(ldt,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldt | |||
| real(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
STPLQT computes a blocked LQ factorization of a real "triangular-pentagonal" matrix C, which is composed of a triangular block A and pentagonal block B, using the compact WY representation for Q.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | l | |||
| integer(kind=ilp), | intent(in) | :: | mb | |||
| real(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=sp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| real(kind=sp), | intent(out) | :: | t(ldt,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldt | |||
| real(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
ZTPLQT computes a blocked LQ factorization of a complex "triangular-pentagonal" matrix C, which is composed of a triangular block A and pentagonal block B, using the compact WY representation for Q.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | l | |||
| integer(kind=ilp), | intent(in) | :: | mb | |||
| complex(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=dp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| complex(kind=dp), | intent(out) | :: | t(ldt,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldt | |||
| complex(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
TPLQT2 computes a LQ a factorization of a complex "triangular-pentagonal" matrix C, which is composed of a triangular block A and pentagonal block B, using the compact WY representation for Q.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | l | |||
| complex(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=sp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| complex(kind=sp), | intent(out) | :: | t(ldt,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldt | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | l | |||
| real(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=dp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| real(kind=dp), | intent(out) | :: | t(ldt,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldt | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | l | |||
| real(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=sp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| real(kind=sp), | intent(out) | :: | t(ldt,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldt | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | l | |||
| complex(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=dp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| complex(kind=dp), | intent(out) | :: | t(ldt,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldt | |||
| integer(kind=ilp), | intent(out) | :: | info |
CTPLQT2 computes a LQ a factorization of a complex "triangular-pentagonal" matrix C, which is composed of a triangular block A and pentagonal block B, using the compact WY representation for Q.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | l | |||
| complex(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=sp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| complex(kind=sp), | intent(out) | :: | t(ldt,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldt | |||
| integer(kind=ilp), | intent(out) | :: | info |
DTPLQT2 computes a LQ a factorization of a real "triangular-pentagonal" matrix C, which is composed of a triangular block A and pentagonal block B, using the compact WY representation for Q.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | l | |||
| real(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=dp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| real(kind=dp), | intent(out) | :: | t(ldt,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldt | |||
| integer(kind=ilp), | intent(out) | :: | info |
STPLQT2 computes a LQ a factorization of a real "triangular-pentagonal" matrix C, which is composed of a triangular block A and pentagonal block B, using the compact WY representation for Q.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | l | |||
| real(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=sp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| real(kind=sp), | intent(out) | :: | t(ldt,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldt | |||
| integer(kind=ilp), | intent(out) | :: | info |
ZTPLQT2 computes a LQ a factorization of a complex "triangular-pentagonal" matrix C, which is composed of a triangular block A and pentagonal block B, using the compact WY representation for Q.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | l | |||
| complex(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=dp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| complex(kind=dp), | intent(out) | :: | t(ldt,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldt | |||
| integer(kind=ilp), | intent(out) | :: | info |
TPMLQT applies a complex unitary matrix Q obtained from a "triangular-pentagonal" complex block reflector H to a general complex matrix C, which consists of two blocks A and B.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | side | |||
| character, | intent(in) | :: | trans | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | k | |||
| integer(kind=ilp), | intent(in) | :: | l | |||
| integer(kind=ilp), | intent(in) | :: | mb | |||
| complex(kind=sp), | intent(in) | :: | v(ldv,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldv | |||
| complex(kind=sp), | intent(in) | :: | t(ldt,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldt | |||
| complex(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=sp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| complex(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | side | |||
| character, | intent(in) | :: | trans | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | k | |||
| integer(kind=ilp), | intent(in) | :: | l | |||
| integer(kind=ilp), | intent(in) | :: | mb | |||
| real(kind=dp), | intent(in) | :: | v(ldv,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldv | |||
| real(kind=dp), | intent(in) | :: | t(ldt,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldt | |||
| real(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=dp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| real(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | side | |||
| character, | intent(in) | :: | trans | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | k | |||
| integer(kind=ilp), | intent(in) | :: | l | |||
| integer(kind=ilp), | intent(in) | :: | mb | |||
| real(kind=sp), | intent(in) | :: | v(ldv,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldv | |||
| real(kind=sp), | intent(in) | :: | t(ldt,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldt | |||
| real(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=sp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| real(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | side | |||
| character, | intent(in) | :: | trans | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | k | |||
| integer(kind=ilp), | intent(in) | :: | l | |||
| integer(kind=ilp), | intent(in) | :: | mb | |||
| complex(kind=dp), | intent(in) | :: | v(ldv,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldv | |||
| complex(kind=dp), | intent(in) | :: | t(ldt,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldt | |||
| complex(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=dp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| complex(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
CTPMLQT applies a complex unitary matrix Q obtained from a "triangular-pentagonal" complex block reflector H to a general complex matrix C, which consists of two blocks A and B.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | side | |||
| character, | intent(in) | :: | trans | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | k | |||
| integer(kind=ilp), | intent(in) | :: | l | |||
| integer(kind=ilp), | intent(in) | :: | mb | |||
| complex(kind=sp), | intent(in) | :: | v(ldv,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldv | |||
| complex(kind=sp), | intent(in) | :: | t(ldt,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldt | |||
| complex(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=sp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| complex(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
DTPMQRT applies a real orthogonal matrix Q obtained from a "triangular-pentagonal" real block reflector H to a general real matrix C, which consists of two blocks A and B.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | side | |||
| character, | intent(in) | :: | trans | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | k | |||
| integer(kind=ilp), | intent(in) | :: | l | |||
| integer(kind=ilp), | intent(in) | :: | mb | |||
| real(kind=dp), | intent(in) | :: | v(ldv,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldv | |||
| real(kind=dp), | intent(in) | :: | t(ldt,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldt | |||
| real(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=dp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| real(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
STPMLQT applies a real orthogonal matrix Q obtained from a "triangular-pentagonal" real block reflector H to a general real matrix C, which consists of two blocks A and B.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | side | |||
| character, | intent(in) | :: | trans | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | k | |||
| integer(kind=ilp), | intent(in) | :: | l | |||
| integer(kind=ilp), | intent(in) | :: | mb | |||
| real(kind=sp), | intent(in) | :: | v(ldv,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldv | |||
| real(kind=sp), | intent(in) | :: | t(ldt,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldt | |||
| real(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=sp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| real(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
ZTPMLQT applies a complex unitary matrix Q obtained from a "triangular-pentagonal" complex block reflector H to a general complex matrix C, which consists of two blocks A and B.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | side | |||
| character, | intent(in) | :: | trans | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | k | |||
| integer(kind=ilp), | intent(in) | :: | l | |||
| integer(kind=ilp), | intent(in) | :: | mb | |||
| complex(kind=dp), | intent(in) | :: | v(ldv,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldv | |||
| complex(kind=dp), | intent(in) | :: | t(ldt,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldt | |||
| complex(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=dp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| complex(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
TPMQRT applies a complex orthogonal matrix Q obtained from a "triangular-pentagonal" complex block reflector H to a general complex matrix C, which consists of two blocks A and B.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | side | |||
| character, | intent(in) | :: | trans | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | k | |||
| integer(kind=ilp), | intent(in) | :: | l | |||
| integer(kind=ilp), | intent(in) | :: | nb | |||
| complex(kind=sp), | intent(in) | :: | v(ldv,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldv | |||
| complex(kind=sp), | intent(in) | :: | t(ldt,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldt | |||
| complex(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=sp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| complex(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | side | |||
| character, | intent(in) | :: | trans | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | k | |||
| integer(kind=ilp), | intent(in) | :: | l | |||
| integer(kind=ilp), | intent(in) | :: | nb | |||
| real(kind=dp), | intent(in) | :: | v(ldv,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldv | |||
| real(kind=dp), | intent(in) | :: | t(ldt,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldt | |||
| real(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=dp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| real(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | side | |||
| character, | intent(in) | :: | trans | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | k | |||
| integer(kind=ilp), | intent(in) | :: | l | |||
| integer(kind=ilp), | intent(in) | :: | nb | |||
| real(kind=sp), | intent(in) | :: | v(ldv,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldv | |||
| real(kind=sp), | intent(in) | :: | t(ldt,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldt | |||
| real(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=sp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| real(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | side | |||
| character, | intent(in) | :: | trans | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | k | |||
| integer(kind=ilp), | intent(in) | :: | l | |||
| integer(kind=ilp), | intent(in) | :: | nb | |||
| complex(kind=dp), | intent(in) | :: | v(ldv,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldv | |||
| complex(kind=dp), | intent(in) | :: | t(ldt,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldt | |||
| complex(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=dp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| complex(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
CTPMQRT applies a complex orthogonal matrix Q obtained from a "triangular-pentagonal" complex block reflector H to a general complex matrix C, which consists of two blocks A and B.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | side | |||
| character, | intent(in) | :: | trans | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | k | |||
| integer(kind=ilp), | intent(in) | :: | l | |||
| integer(kind=ilp), | intent(in) | :: | nb | |||
| complex(kind=sp), | intent(in) | :: | v(ldv,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldv | |||
| complex(kind=sp), | intent(in) | :: | t(ldt,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldt | |||
| complex(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=sp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| complex(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
DTPMQRT applies a real orthogonal matrix Q obtained from a "triangular-pentagonal" real block reflector H to a general real matrix C, which consists of two blocks A and B.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | side | |||
| character, | intent(in) | :: | trans | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | k | |||
| integer(kind=ilp), | intent(in) | :: | l | |||
| integer(kind=ilp), | intent(in) | :: | nb | |||
| real(kind=dp), | intent(in) | :: | v(ldv,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldv | |||
| real(kind=dp), | intent(in) | :: | t(ldt,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldt | |||
| real(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=dp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| real(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
STPMQRT applies a real orthogonal matrix Q obtained from a "triangular-pentagonal" real block reflector H to a general real matrix C, which consists of two blocks A and B.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | side | |||
| character, | intent(in) | :: | trans | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | k | |||
| integer(kind=ilp), | intent(in) | :: | l | |||
| integer(kind=ilp), | intent(in) | :: | nb | |||
| real(kind=sp), | intent(in) | :: | v(ldv,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldv | |||
| real(kind=sp), | intent(in) | :: | t(ldt,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldt | |||
| real(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=sp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| real(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
ZTPMQRT applies a complex orthogonal matrix Q obtained from a "triangular-pentagonal" complex block reflector H to a general complex matrix C, which consists of two blocks A and B.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | side | |||
| character, | intent(in) | :: | trans | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | k | |||
| integer(kind=ilp), | intent(in) | :: | l | |||
| integer(kind=ilp), | intent(in) | :: | nb | |||
| complex(kind=dp), | intent(in) | :: | v(ldv,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldv | |||
| complex(kind=dp), | intent(in) | :: | t(ldt,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldt | |||
| complex(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=dp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| complex(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
TPQRT computes a blocked QR factorization of a complex "triangular-pentagonal" matrix C, which is composed of a triangular block A and pentagonal block B, using the compact WY representation for Q.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | l | |||
| integer(kind=ilp), | intent(in) | :: | nb | |||
| complex(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=sp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| complex(kind=sp), | intent(out) | :: | t(ldt,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldt | |||
| complex(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | l | |||
| integer(kind=ilp), | intent(in) | :: | nb | |||
| real(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=dp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| real(kind=dp), | intent(out) | :: | t(ldt,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldt | |||
| real(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | l | |||
| integer(kind=ilp), | intent(in) | :: | nb | |||
| real(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=sp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| real(kind=sp), | intent(out) | :: | t(ldt,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldt | |||
| real(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | l | |||
| integer(kind=ilp), | intent(in) | :: | nb | |||
| complex(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=dp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| complex(kind=dp), | intent(out) | :: | t(ldt,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldt | |||
| complex(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
CTPQRT computes a blocked QR factorization of a complex "triangular-pentagonal" matrix C, which is composed of a triangular block A and pentagonal block B, using the compact WY representation for Q.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | l | |||
| integer(kind=ilp), | intent(in) | :: | nb | |||
| complex(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=sp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| complex(kind=sp), | intent(out) | :: | t(ldt,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldt | |||
| complex(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
DTPQRT computes a blocked QR factorization of a real "triangular-pentagonal" matrix C, which is composed of a triangular block A and pentagonal block B, using the compact WY representation for Q.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | l | |||
| integer(kind=ilp), | intent(in) | :: | nb | |||
| real(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=dp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| real(kind=dp), | intent(out) | :: | t(ldt,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldt | |||
| real(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
STPQRT computes a blocked QR factorization of a real "triangular-pentagonal" matrix C, which is composed of a triangular block A and pentagonal block B, using the compact WY representation for Q.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | l | |||
| integer(kind=ilp), | intent(in) | :: | nb | |||
| real(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=sp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| real(kind=sp), | intent(out) | :: | t(ldt,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldt | |||
| real(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
ZTPQRT computes a blocked QR factorization of a complex "triangular-pentagonal" matrix C, which is composed of a triangular block A and pentagonal block B, using the compact WY representation for Q.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | l | |||
| integer(kind=ilp), | intent(in) | :: | nb | |||
| complex(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=dp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| complex(kind=dp), | intent(out) | :: | t(ldt,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldt | |||
| complex(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
TPQRT2 computes a QR factorization of a complex "triangular-pentagonal" matrix C, which is composed of a triangular block A and pentagonal block B, using the compact WY representation for Q.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | l | |||
| complex(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=sp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| complex(kind=sp), | intent(out) | :: | t(ldt,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldt | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | l | |||
| real(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=dp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| real(kind=dp), | intent(out) | :: | t(ldt,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldt | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | l | |||
| real(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=sp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| real(kind=sp), | intent(out) | :: | t(ldt,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldt | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | l | |||
| complex(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=dp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| complex(kind=dp), | intent(out) | :: | t(ldt,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldt | |||
| integer(kind=ilp), | intent(out) | :: | info |
CTPQRT2 computes a QR factorization of a complex "triangular-pentagonal" matrix C, which is composed of a triangular block A and pentagonal block B, using the compact WY representation for Q.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | l | |||
| complex(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=sp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| complex(kind=sp), | intent(out) | :: | t(ldt,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldt | |||
| integer(kind=ilp), | intent(out) | :: | info |
DTPQRT2 computes a QR factorization of a real "triangular-pentagonal" matrix C, which is composed of a triangular block A and pentagonal block B, using the compact WY representation for Q.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | l | |||
| real(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=dp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| real(kind=dp), | intent(out) | :: | t(ldt,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldt | |||
| integer(kind=ilp), | intent(out) | :: | info |
STPQRT2 computes a QR factorization of a real "triangular-pentagonal" matrix C, which is composed of a triangular block A and pentagonal block B, using the compact WY representation for Q.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | l | |||
| real(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=sp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| real(kind=sp), | intent(out) | :: | t(ldt,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldt | |||
| integer(kind=ilp), | intent(out) | :: | info |
ZTPQRT2 computes a QR factorization of a complex "triangular-pentagonal" matrix C, which is composed of a triangular block A and pentagonal block B, using the compact WY representation for Q.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | l | |||
| complex(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=dp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| complex(kind=dp), | intent(out) | :: | t(ldt,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldt | |||
| integer(kind=ilp), | intent(out) | :: | info |
TPRFB applies a complex "triangular-pentagonal" block reflector H or its conjugate transpose H**H to a complex matrix C, which is composed of two blocks A and B, either from the left or right.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | side | |||
| character, | intent(in) | :: | trans | |||
| character, | intent(in) | :: | direct | |||
| character, | intent(in) | :: | storev | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | k | |||
| integer(kind=ilp), | intent(in) | :: | l | |||
| complex(kind=sp), | intent(in) | :: | v(ldv,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldv | |||
| complex(kind=sp), | intent(in) | :: | t(ldt,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldt | |||
| complex(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=sp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| complex(kind=sp), | intent(out) | :: | work(ldwork,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldwork |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | side | |||
| character, | intent(in) | :: | trans | |||
| character, | intent(in) | :: | direct | |||
| character, | intent(in) | :: | storev | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | k | |||
| integer(kind=ilp), | intent(in) | :: | l | |||
| real(kind=dp), | intent(in) | :: | v(ldv,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldv | |||
| real(kind=dp), | intent(in) | :: | t(ldt,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldt | |||
| real(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=dp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| real(kind=dp), | intent(out) | :: | work(ldwork,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldwork |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | side | |||
| character, | intent(in) | :: | trans | |||
| character, | intent(in) | :: | direct | |||
| character, | intent(in) | :: | storev | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | k | |||
| integer(kind=ilp), | intent(in) | :: | l | |||
| real(kind=sp), | intent(in) | :: | v(ldv,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldv | |||
| real(kind=sp), | intent(in) | :: | t(ldt,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldt | |||
| real(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=sp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| real(kind=sp), | intent(out) | :: | work(ldwork,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldwork |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | side | |||
| character, | intent(in) | :: | trans | |||
| character, | intent(in) | :: | direct | |||
| character, | intent(in) | :: | storev | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | k | |||
| integer(kind=ilp), | intent(in) | :: | l | |||
| complex(kind=dp), | intent(in) | :: | v(ldv,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldv | |||
| complex(kind=dp), | intent(in) | :: | t(ldt,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldt | |||
| complex(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=dp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| complex(kind=dp), | intent(out) | :: | work(ldwork,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldwork |
CTPRFB applies a complex "triangular-pentagonal" block reflector H or its conjugate transpose H**H to a complex matrix C, which is composed of two blocks A and B, either from the left or right.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | side | |||
| character, | intent(in) | :: | trans | |||
| character, | intent(in) | :: | direct | |||
| character, | intent(in) | :: | storev | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | k | |||
| integer(kind=ilp), | intent(in) | :: | l | |||
| complex(kind=sp), | intent(in) | :: | v(ldv,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldv | |||
| complex(kind=sp), | intent(in) | :: | t(ldt,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldt | |||
| complex(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=sp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| complex(kind=sp), | intent(out) | :: | work(ldwork,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldwork |
DTPRFB applies a real "triangular-pentagonal" block reflector H or its transpose H**T to a real matrix C, which is composed of two blocks A and B, either from the left or right.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | side | |||
| character, | intent(in) | :: | trans | |||
| character, | intent(in) | :: | direct | |||
| character, | intent(in) | :: | storev | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | k | |||
| integer(kind=ilp), | intent(in) | :: | l | |||
| real(kind=dp), | intent(in) | :: | v(ldv,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldv | |||
| real(kind=dp), | intent(in) | :: | t(ldt,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldt | |||
| real(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=dp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| real(kind=dp), | intent(out) | :: | work(ldwork,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldwork |
STPRFB applies a real "triangular-pentagonal" block reflector H or its conjugate transpose H^H to a real matrix C, which is composed of two blocks A and B, either from the left or right.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | side | |||
| character, | intent(in) | :: | trans | |||
| character, | intent(in) | :: | direct | |||
| character, | intent(in) | :: | storev | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | k | |||
| integer(kind=ilp), | intent(in) | :: | l | |||
| real(kind=sp), | intent(in) | :: | v(ldv,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldv | |||
| real(kind=sp), | intent(in) | :: | t(ldt,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldt | |||
| real(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=sp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| real(kind=sp), | intent(out) | :: | work(ldwork,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldwork |
ZTPRFB applies a complex "triangular-pentagonal" block reflector H or its conjugate transpose H**H to a complex matrix C, which is composed of two blocks A and B, either from the left or right.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | side | |||
| character, | intent(in) | :: | trans | |||
| character, | intent(in) | :: | direct | |||
| character, | intent(in) | :: | storev | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | k | |||
| integer(kind=ilp), | intent(in) | :: | l | |||
| complex(kind=dp), | intent(in) | :: | v(ldv,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldv | |||
| complex(kind=dp), | intent(in) | :: | t(ldt,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldt | |||
| complex(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=dp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| complex(kind=dp), | intent(out) | :: | work(ldwork,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldwork |
TPRFS provides error bounds and backward error estimates for the solution to a system of linear equations with a triangular packed coefficient matrix. The solution matrix X must be computed by CTPTRS or some other means before entering this routine. TPRFS does not do iterative refinement because doing so cannot improve the backward error.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| character, | intent(in) | :: | trans | |||
| character, | intent(in) | :: | diag | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| complex(kind=sp), | intent(in) | :: | ap(*) | |||
| complex(kind=sp), | intent(in) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| complex(kind=sp), | intent(in) | :: | x(ldx,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldx | |||
| real(kind=sp), | intent(out) | :: | ferr(*) | |||
| real(kind=sp), | intent(out) | :: | berr(*) | |||
| complex(kind=sp), | intent(out) | :: | work(*) | |||
| real(kind=sp), | intent(out) | :: | rwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| character, | intent(in) | :: | trans | |||
| character, | intent(in) | :: | diag | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| real(kind=dp), | intent(in) | :: | ap(*) | |||
| real(kind=dp), | intent(in) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| real(kind=dp), | intent(in) | :: | x(ldx,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldx | |||
| real(kind=dp), | intent(out) | :: | ferr(*) | |||
| real(kind=dp), | intent(out) | :: | berr(*) | |||
| real(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | iwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| character, | intent(in) | :: | trans | |||
| character, | intent(in) | :: | diag | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| real(kind=sp), | intent(in) | :: | ap(*) | |||
| real(kind=sp), | intent(in) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| real(kind=sp), | intent(in) | :: | x(ldx,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldx | |||
| real(kind=sp), | intent(out) | :: | ferr(*) | |||
| real(kind=sp), | intent(out) | :: | berr(*) | |||
| real(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | iwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| character, | intent(in) | :: | trans | |||
| character, | intent(in) | :: | diag | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| complex(kind=dp), | intent(in) | :: | ap(*) | |||
| complex(kind=dp), | intent(in) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| complex(kind=dp), | intent(in) | :: | x(ldx,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldx | |||
| real(kind=dp), | intent(out) | :: | ferr(*) | |||
| real(kind=dp), | intent(out) | :: | berr(*) | |||
| complex(kind=dp), | intent(out) | :: | work(*) | |||
| real(kind=dp), | intent(out) | :: | rwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
CTPRFS provides error bounds and backward error estimates for the solution to a system of linear equations with a triangular packed coefficient matrix. The solution matrix X must be computed by CTPTRS or some other means before entering this routine. CTPRFS does not do iterative refinement because doing so cannot improve the backward error.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| character, | intent(in) | :: | trans | |||
| character, | intent(in) | :: | diag | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| complex(kind=sp), | intent(in) | :: | ap(*) | |||
| complex(kind=sp), | intent(in) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| complex(kind=sp), | intent(in) | :: | x(ldx,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldx | |||
| real(kind=sp), | intent(out) | :: | ferr(*) | |||
| real(kind=sp), | intent(out) | :: | berr(*) | |||
| complex(kind=sp), | intent(out) | :: | work(*) | |||
| real(kind=sp), | intent(out) | :: | rwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
DTPRFS provides error bounds and backward error estimates for the solution to a system of linear equations with a triangular packed coefficient matrix. The solution matrix X must be computed by DTPTRS or some other means before entering this routine. DTPRFS does not do iterative refinement because doing so cannot improve the backward error.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| character, | intent(in) | :: | trans | |||
| character, | intent(in) | :: | diag | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| real(kind=dp), | intent(in) | :: | ap(*) | |||
| real(kind=dp), | intent(in) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| real(kind=dp), | intent(in) | :: | x(ldx,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldx | |||
| real(kind=dp), | intent(out) | :: | ferr(*) | |||
| real(kind=dp), | intent(out) | :: | berr(*) | |||
| real(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | iwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
STPRFS provides error bounds and backward error estimates for the solution to a system of linear equations with a triangular packed coefficient matrix. The solution matrix X must be computed by STPTRS or some other means before entering this routine. STPRFS does not do iterative refinement because doing so cannot improve the backward error.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| character, | intent(in) | :: | trans | |||
| character, | intent(in) | :: | diag | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| real(kind=sp), | intent(in) | :: | ap(*) | |||
| real(kind=sp), | intent(in) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| real(kind=sp), | intent(in) | :: | x(ldx,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldx | |||
| real(kind=sp), | intent(out) | :: | ferr(*) | |||
| real(kind=sp), | intent(out) | :: | berr(*) | |||
| real(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | iwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
ZTPRFS provides error bounds and backward error estimates for the solution to a system of linear equations with a triangular packed coefficient matrix. The solution matrix X must be computed by ZTPTRS or some other means before entering this routine. ZTPRFS does not do iterative refinement because doing so cannot improve the backward error.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| character, | intent(in) | :: | trans | |||
| character, | intent(in) | :: | diag | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| complex(kind=dp), | intent(in) | :: | ap(*) | |||
| complex(kind=dp), | intent(in) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| complex(kind=dp), | intent(in) | :: | x(ldx,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldx | |||
| real(kind=dp), | intent(out) | :: | ferr(*) | |||
| real(kind=dp), | intent(out) | :: | berr(*) | |||
| complex(kind=dp), | intent(out) | :: | work(*) | |||
| real(kind=dp), | intent(out) | :: | rwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
TPTRI computes the inverse of a complex upper or lower triangular matrix A stored in packed format.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| character, | intent(in) | :: | diag | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=sp), | intent(inout) | :: | ap(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| character, | intent(in) | :: | diag | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=dp), | intent(inout) | :: | ap(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| character, | intent(in) | :: | diag | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=sp), | intent(inout) | :: | ap(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| character, | intent(in) | :: | diag | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=dp), | intent(inout) | :: | ap(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
CTPTRI computes the inverse of a complex upper or lower triangular matrix A stored in packed format.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| character, | intent(in) | :: | diag | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=sp), | intent(inout) | :: | ap(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
DTPTRI computes the inverse of a real upper or lower triangular matrix A stored in packed format.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| character, | intent(in) | :: | diag | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=dp), | intent(inout) | :: | ap(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
STPTRI computes the inverse of a real upper or lower triangular matrix A stored in packed format.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| character, | intent(in) | :: | diag | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=sp), | intent(inout) | :: | ap(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
ZTPTRI computes the inverse of a complex upper or lower triangular matrix A stored in packed format.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| character, | intent(in) | :: | diag | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=dp), | intent(inout) | :: | ap(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
TPTRS solves a triangular system of the form A * X = B, AT * X = B, or AH * X = B, where A is a triangular matrix of order N stored in packed format, and B is an N-by-NRHS matrix. A check is made to verify that A is nonsingular.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| character, | intent(in) | :: | trans | |||
| character, | intent(in) | :: | diag | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| complex(kind=sp), | intent(in) | :: | ap(*) | |||
| complex(kind=sp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| character, | intent(in) | :: | trans | |||
| character, | intent(in) | :: | diag | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| real(kind=dp), | intent(in) | :: | ap(*) | |||
| real(kind=dp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| character, | intent(in) | :: | trans | |||
| character, | intent(in) | :: | diag | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| real(kind=sp), | intent(in) | :: | ap(*) | |||
| real(kind=sp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| character, | intent(in) | :: | trans | |||
| character, | intent(in) | :: | diag | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| complex(kind=dp), | intent(in) | :: | ap(*) | |||
| complex(kind=dp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| integer(kind=ilp), | intent(out) | :: | info |
CTPTRS solves a triangular system of the form A * X = B, AT * X = B, or AH * X = B, where A is a triangular matrix of order N stored in packed format, and B is an N-by-NRHS matrix. A check is made to verify that A is nonsingular.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| character, | intent(in) | :: | trans | |||
| character, | intent(in) | :: | diag | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| complex(kind=sp), | intent(in) | :: | ap(*) | |||
| complex(kind=sp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| integer(kind=ilp), | intent(out) | :: | info |
DTPTRS solves a triangular system of the form A * X = B or A**T * X = B, where A is a triangular matrix of order N stored in packed format, and B is an N-by-NRHS matrix. A check is made to verify that A is nonsingular.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| character, | intent(in) | :: | trans | |||
| character, | intent(in) | :: | diag | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| real(kind=dp), | intent(in) | :: | ap(*) | |||
| real(kind=dp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| integer(kind=ilp), | intent(out) | :: | info |
STPTRS solves a triangular system of the form A * X = B or A**T * X = B, where A is a triangular matrix of order N stored in packed format, and B is an N-by-NRHS matrix. A check is made to verify that A is nonsingular.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| character, | intent(in) | :: | trans | |||
| character, | intent(in) | :: | diag | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| real(kind=sp), | intent(in) | :: | ap(*) | |||
| real(kind=sp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| integer(kind=ilp), | intent(out) | :: | info |
ZTPTRS solves a triangular system of the form A * X = B, AT * X = B, or AH * X = B, where A is a triangular matrix of order N stored in packed format, and B is an N-by-NRHS matrix. A check is made to verify that A is nonsingular.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| character, | intent(in) | :: | trans | |||
| character, | intent(in) | :: | diag | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| complex(kind=dp), | intent(in) | :: | ap(*) | |||
| complex(kind=dp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| integer(kind=ilp), | intent(out) | :: | info |
TPTTF copies a triangular matrix A from standard packed format (TP) to rectangular full packed format (TF).
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | transr | |||
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=sp), | intent(in) | :: | ap(0:*) | |||
| complex(kind=sp), | intent(out) | :: | arf(0:*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | transr | |||
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=dp), | intent(in) | :: | ap(0:*) | |||
| real(kind=dp), | intent(out) | :: | arf(0:*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | transr | |||
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=sp), | intent(in) | :: | ap(0:*) | |||
| real(kind=sp), | intent(out) | :: | arf(0:*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | transr | |||
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=dp), | intent(in) | :: | ap(0:*) | |||
| complex(kind=dp), | intent(out) | :: | arf(0:*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
CTPTTF copies a triangular matrix A from standard packed format (TP) to rectangular full packed format (TF).
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | transr | |||
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=sp), | intent(in) | :: | ap(0:*) | |||
| complex(kind=sp), | intent(out) | :: | arf(0:*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
DTPTTF copies a triangular matrix A from standard packed format (TP) to rectangular full packed format (TF).
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | transr | |||
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=dp), | intent(in) | :: | ap(0:*) | |||
| real(kind=dp), | intent(out) | :: | arf(0:*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
STPTTF copies a triangular matrix A from standard packed format (TP) to rectangular full packed format (TF).
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | transr | |||
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=sp), | intent(in) | :: | ap(0:*) | |||
| real(kind=sp), | intent(out) | :: | arf(0:*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
ZTPTTF copies a triangular matrix A from standard packed format (TP) to rectangular full packed format (TF).
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | transr | |||
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=dp), | intent(in) | :: | ap(0:*) | |||
| complex(kind=dp), | intent(out) | :: | arf(0:*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
TPTTR copies a triangular matrix A from standard packed format (TP) to standard full format (TR).
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=sp), | intent(in) | :: | ap(*) | |||
| complex(kind=sp), | intent(out) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=dp), | intent(in) | :: | ap(*) | |||
| real(kind=dp), | intent(out) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=sp), | intent(in) | :: | ap(*) | |||
| real(kind=sp), | intent(out) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=dp), | intent(in) | :: | ap(*) | |||
| complex(kind=dp), | intent(out) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| integer(kind=ilp), | intent(out) | :: | info |
CTPTTR copies a triangular matrix A from standard packed format (TP) to standard full format (TR).
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=sp), | intent(in) | :: | ap(*) | |||
| complex(kind=sp), | intent(out) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| integer(kind=ilp), | intent(out) | :: | info |
DTPTTR copies a triangular matrix A from standard packed format (TP) to standard full format (TR).
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=dp), | intent(in) | :: | ap(*) | |||
| real(kind=dp), | intent(out) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| integer(kind=ilp), | intent(out) | :: | info |
STPTTR copies a triangular matrix A from standard packed format (TP) to standard full format (TR).
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=sp), | intent(in) | :: | ap(*) | |||
| real(kind=sp), | intent(out) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| integer(kind=ilp), | intent(out) | :: | info |
ZTPTTR copies a triangular matrix A from standard packed format (TP) to standard full format (TR).
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=dp), | intent(in) | :: | ap(*) | |||
| complex(kind=dp), | intent(out) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| integer(kind=ilp), | intent(out) | :: | info |
TRCON estimates the reciprocal of the condition number of a triangular matrix A, in either the 1-norm or the infinity-norm. The norm of A is computed and an estimate is obtained for norm(inv(A)), then the reciprocal of the condition number is computed as RCOND = 1 / ( norm(A) * norm(inv(A)) ).
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | norm | |||
| character, | intent(in) | :: | uplo | |||
| character, | intent(in) | :: | diag | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=sp), | intent(in) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=sp), | intent(out) | :: | rcond | |||
| complex(kind=sp), | intent(out) | :: | work(*) | |||
| real(kind=sp), | intent(out) | :: | rwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | norm | |||
| character, | intent(in) | :: | uplo | |||
| character, | intent(in) | :: | diag | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=dp), | intent(in) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=dp), | intent(out) | :: | rcond | |||
| real(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | iwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | norm | |||
| character, | intent(in) | :: | uplo | |||
| character, | intent(in) | :: | diag | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=sp), | intent(in) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=sp), | intent(out) | :: | rcond | |||
| real(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | iwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | norm | |||
| character, | intent(in) | :: | uplo | |||
| character, | intent(in) | :: | diag | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=dp), | intent(in) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=dp), | intent(out) | :: | rcond | |||
| complex(kind=dp), | intent(out) | :: | work(*) | |||
| real(kind=dp), | intent(out) | :: | rwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
CTRCON estimates the reciprocal of the condition number of a triangular matrix A, in either the 1-norm or the infinity-norm. The norm of A is computed and an estimate is obtained for norm(inv(A)), then the reciprocal of the condition number is computed as RCOND = 1 / ( norm(A) * norm(inv(A)) ).
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | norm | |||
| character, | intent(in) | :: | uplo | |||
| character, | intent(in) | :: | diag | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=sp), | intent(in) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=sp), | intent(out) | :: | rcond | |||
| complex(kind=sp), | intent(out) | :: | work(*) | |||
| real(kind=sp), | intent(out) | :: | rwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
DTRCON estimates the reciprocal of the condition number of a triangular matrix A, in either the 1-norm or the infinity-norm. The norm of A is computed and an estimate is obtained for norm(inv(A)), then the reciprocal of the condition number is computed as RCOND = 1 / ( norm(A) * norm(inv(A)) ).
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | norm | |||
| character, | intent(in) | :: | uplo | |||
| character, | intent(in) | :: | diag | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=dp), | intent(in) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=dp), | intent(out) | :: | rcond | |||
| real(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | iwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
STRCON estimates the reciprocal of the condition number of a triangular matrix A, in either the 1-norm or the infinity-norm. The norm of A is computed and an estimate is obtained for norm(inv(A)), then the reciprocal of the condition number is computed as RCOND = 1 / ( norm(A) * norm(inv(A)) ).
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | norm | |||
| character, | intent(in) | :: | uplo | |||
| character, | intent(in) | :: | diag | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=sp), | intent(in) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=sp), | intent(out) | :: | rcond | |||
| real(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | iwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
ZTRCON estimates the reciprocal of the condition number of a triangular matrix A, in either the 1-norm or the infinity-norm. The norm of A is computed and an estimate is obtained for norm(inv(A)), then the reciprocal of the condition number is computed as RCOND = 1 / ( norm(A) * norm(inv(A)) ).
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | norm | |||
| character, | intent(in) | :: | uplo | |||
| character, | intent(in) | :: | diag | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=dp), | intent(in) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=dp), | intent(out) | :: | rcond | |||
| complex(kind=dp), | intent(out) | :: | work(*) | |||
| real(kind=dp), | intent(out) | :: | rwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
TREVC computes some or all of the right and/or left eigenvectors of a complex upper triangular matrix T. Matrices of this type are produced by the Schur factorization of a complex general matrix: A = QTQH, as computed by CHSEQR. The right eigenvector x and the left eigenvector y of T corresponding to an eigenvalue w are defined by: Tx = wx, (yH)T = w(yH) where yH denotes the conjugate transpose of the vector y. The eigenvalues are not input to this routine, but are read directly from the diagonal of T. This routine returns the matrices X and/or Y of right and left eigenvectors of T, or the products QX and/or QY, where Q is an input matrix. If Q is the unitary factor that reduces a matrix A to Schur form T, then QX and QY are the matrices of right and left eigenvectors of A.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | side | |||
| character, | intent(in) | :: | howmny | |||
| logical(kind=lk), | intent(in) | :: | select(*) | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=sp), | intent(inout) | :: | t(ldt,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldt | |||
| complex(kind=sp), | intent(inout) | :: | vl(ldvl,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldvl | |||
| complex(kind=sp), | intent(inout) | :: | vr(ldvr,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldvr | |||
| integer(kind=ilp), | intent(in) | :: | mm | |||
| integer(kind=ilp), | intent(out) | :: | m | |||
| complex(kind=sp), | intent(out) | :: | work(*) | |||
| real(kind=sp), | intent(out) | :: | rwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | side | |||
| character, | intent(in) | :: | howmny | |||
| logical(kind=lk), | intent(inout) | :: | select(*) | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=dp), | intent(in) | :: | t(ldt,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldt | |||
| real(kind=dp), | intent(inout) | :: | vl(ldvl,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldvl | |||
| real(kind=dp), | intent(inout) | :: | vr(ldvr,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldvr | |||
| integer(kind=ilp), | intent(in) | :: | mm | |||
| integer(kind=ilp), | intent(out) | :: | m | |||
| real(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | side | |||
| character, | intent(in) | :: | howmny | |||
| logical(kind=lk), | intent(inout) | :: | select(*) | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=sp), | intent(in) | :: | t(ldt,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldt | |||
| real(kind=sp), | intent(inout) | :: | vl(ldvl,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldvl | |||
| real(kind=sp), | intent(inout) | :: | vr(ldvr,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldvr | |||
| integer(kind=ilp), | intent(in) | :: | mm | |||
| integer(kind=ilp), | intent(out) | :: | m | |||
| real(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | side | |||
| character, | intent(in) | :: | howmny | |||
| logical(kind=lk), | intent(in) | :: | select(*) | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=dp), | intent(inout) | :: | t(ldt,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldt | |||
| complex(kind=dp), | intent(inout) | :: | vl(ldvl,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldvl | |||
| complex(kind=dp), | intent(inout) | :: | vr(ldvr,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldvr | |||
| integer(kind=ilp), | intent(in) | :: | mm | |||
| integer(kind=ilp), | intent(out) | :: | m | |||
| complex(kind=dp), | intent(out) | :: | work(*) | |||
| real(kind=dp), | intent(out) | :: | rwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
CTREVC computes some or all of the right and/or left eigenvectors of a complex upper triangular matrix T. Matrices of this type are produced by the Schur factorization of a complex general matrix: A = QTQH, as computed by CHSEQR. The right eigenvector x and the left eigenvector y of T corresponding to an eigenvalue w are defined by: Tx = wx, (yH)T = w(yH) where yH denotes the conjugate transpose of the vector y. The eigenvalues are not input to this routine, but are read directly from the diagonal of T. This routine returns the matrices X and/or Y of right and left eigenvectors of T, or the products QX and/or QY, where Q is an input matrix. If Q is the unitary factor that reduces a matrix A to Schur form T, then QX and QY are the matrices of right and left eigenvectors of A.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | side | |||
| character, | intent(in) | :: | howmny | |||
| logical(kind=lk), | intent(in) | :: | select(*) | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=sp), | intent(inout) | :: | t(ldt,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldt | |||
| complex(kind=sp), | intent(inout) | :: | vl(ldvl,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldvl | |||
| complex(kind=sp), | intent(inout) | :: | vr(ldvr,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldvr | |||
| integer(kind=ilp), | intent(in) | :: | mm | |||
| integer(kind=ilp), | intent(out) | :: | m | |||
| complex(kind=sp), | intent(out) | :: | work(*) | |||
| real(kind=sp), | intent(out) | :: | rwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
DTREVC computes some or all of the right and/or left eigenvectors of a real upper quasi-triangular matrix T. Matrices of this type are produced by the Schur factorization of a real general matrix: A = QTQT, as computed by DHSEQR. The right eigenvector x and the left eigenvector y of T corresponding to an eigenvalue w are defined by: Tx = wx, (yH)T = w(yH) where yH denotes the conjugate transpose of y. The eigenvalues are not input to this routine, but are read directly from the diagonal blocks of T. This routine returns the matrices X and/or Y of right and left eigenvectors of T, or the products QX and/or QY, where Q is an input matrix. If Q is the orthogonal factor that reduces a matrix A to Schur form T, then QX and QY are the matrices of right and left eigenvectors of A.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | side | |||
| character, | intent(in) | :: | howmny | |||
| logical(kind=lk), | intent(inout) | :: | select(*) | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=dp), | intent(in) | :: | t(ldt,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldt | |||
| real(kind=dp), | intent(inout) | :: | vl(ldvl,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldvl | |||
| real(kind=dp), | intent(inout) | :: | vr(ldvr,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldvr | |||
| integer(kind=ilp), | intent(in) | :: | mm | |||
| integer(kind=ilp), | intent(out) | :: | m | |||
| real(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
STREVC computes some or all of the right and/or left eigenvectors of a real upper quasi-triangular matrix T. Matrices of this type are produced by the Schur factorization of a real general matrix: A = QTQT, as computed by SHSEQR. The right eigenvector x and the left eigenvector y of T corresponding to an eigenvalue w are defined by: Tx = wx, (yH)T = w(yH) where yH denotes the conjugate transpose of y. The eigenvalues are not input to this routine, but are read directly from the diagonal blocks of T. This routine returns the matrices X and/or Y of right and left eigenvectors of T, or the products QX and/or QY, where Q is an input matrix. If Q is the orthogonal factor that reduces a matrix A to Schur form T, then QX and QY are the matrices of right and left eigenvectors of A.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | side | |||
| character, | intent(in) | :: | howmny | |||
| logical(kind=lk), | intent(inout) | :: | select(*) | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=sp), | intent(in) | :: | t(ldt,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldt | |||
| real(kind=sp), | intent(inout) | :: | vl(ldvl,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldvl | |||
| real(kind=sp), | intent(inout) | :: | vr(ldvr,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldvr | |||
| integer(kind=ilp), | intent(in) | :: | mm | |||
| integer(kind=ilp), | intent(out) | :: | m | |||
| real(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
ZTREVC computes some or all of the right and/or left eigenvectors of a complex upper triangular matrix T. Matrices of this type are produced by the Schur factorization of a complex general matrix: A = QTQH, as computed by ZHSEQR. The right eigenvector x and the left eigenvector y of T corresponding to an eigenvalue w are defined by: Tx = wx, (yH)T = w(yH) where yH denotes the conjugate transpose of the vector y. The eigenvalues are not input to this routine, but are read directly from the diagonal of T. This routine returns the matrices X and/or Y of right and left eigenvectors of T, or the products QX and/or QY, where Q is an input matrix. If Q is the unitary factor that reduces a matrix A to Schur form T, then QX and QY are the matrices of right and left eigenvectors of A.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | side | |||
| character, | intent(in) | :: | howmny | |||
| logical(kind=lk), | intent(in) | :: | select(*) | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=dp), | intent(inout) | :: | t(ldt,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldt | |||
| complex(kind=dp), | intent(inout) | :: | vl(ldvl,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldvl | |||
| complex(kind=dp), | intent(inout) | :: | vr(ldvr,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldvr | |||
| integer(kind=ilp), | intent(in) | :: | mm | |||
| integer(kind=ilp), | intent(out) | :: | m | |||
| complex(kind=dp), | intent(out) | :: | work(*) | |||
| real(kind=dp), | intent(out) | :: | rwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
TREVC3 computes some or all of the right and/or left eigenvectors of a complex upper triangular matrix T. Matrices of this type are produced by the Schur factorization of a complex general matrix: A = QTQH, as computed by CHSEQR. The right eigenvector x and the left eigenvector y of T corresponding to an eigenvalue w are defined by: Tx = wx, (yH)T = w(yH) where yH denotes the conjugate transpose of the vector y. The eigenvalues are not input to this routine, but are read directly from the diagonal of T. This routine returns the matrices X and/or Y of right and left eigenvectors of T, or the products QX and/or QY, where Q is an input matrix. If Q is the unitary factor that reduces a matrix A to Schur form T, then QX and QY are the matrices of right and left eigenvectors of A. This uses a Level 3 BLAS version of the back transformation.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | side | |||
| character, | intent(in) | :: | howmny | |||
| logical(kind=lk), | intent(in) | :: | select(*) | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=sp), | intent(inout) | :: | t(ldt,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldt | |||
| complex(kind=sp), | intent(inout) | :: | vl(ldvl,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldvl | |||
| complex(kind=sp), | intent(inout) | :: | vr(ldvr,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldvr | |||
| integer(kind=ilp), | intent(in) | :: | mm | |||
| integer(kind=ilp), | intent(out) | :: | m | |||
| complex(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| real(kind=sp), | intent(out) | :: | rwork(*) | |||
| integer(kind=ilp), | intent(in) | :: | lrwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | side | |||
| character, | intent(in) | :: | howmny | |||
| logical(kind=lk), | intent(inout) | :: | select(*) | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=dp), | intent(in) | :: | t(ldt,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldt | |||
| real(kind=dp), | intent(inout) | :: | vl(ldvl,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldvl | |||
| real(kind=dp), | intent(inout) | :: | vr(ldvr,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldvr | |||
| integer(kind=ilp), | intent(in) | :: | mm | |||
| integer(kind=ilp), | intent(out) | :: | m | |||
| real(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | side | |||
| character, | intent(in) | :: | howmny | |||
| logical(kind=lk), | intent(inout) | :: | select(*) | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=sp), | intent(in) | :: | t(ldt,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldt | |||
| real(kind=sp), | intent(inout) | :: | vl(ldvl,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldvl | |||
| real(kind=sp), | intent(inout) | :: | vr(ldvr,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldvr | |||
| integer(kind=ilp), | intent(in) | :: | mm | |||
| integer(kind=ilp), | intent(out) | :: | m | |||
| real(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | side | |||
| character, | intent(in) | :: | howmny | |||
| logical(kind=lk), | intent(in) | :: | select(*) | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=dp), | intent(inout) | :: | t(ldt,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldt | |||
| complex(kind=dp), | intent(inout) | :: | vl(ldvl,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldvl | |||
| complex(kind=dp), | intent(inout) | :: | vr(ldvr,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldvr | |||
| integer(kind=ilp), | intent(in) | :: | mm | |||
| integer(kind=ilp), | intent(out) | :: | m | |||
| complex(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| real(kind=dp), | intent(out) | :: | rwork(*) | |||
| integer(kind=ilp), | intent(in) | :: | lrwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
CTREVC3 computes some or all of the right and/or left eigenvectors of a complex upper triangular matrix T. Matrices of this type are produced by the Schur factorization of a complex general matrix: A = QTQH, as computed by CHSEQR. The right eigenvector x and the left eigenvector y of T corresponding to an eigenvalue w are defined by: Tx = wx, (yH)T = w(yH) where yH denotes the conjugate transpose of the vector y. The eigenvalues are not input to this routine, but are read directly from the diagonal of T. This routine returns the matrices X and/or Y of right and left eigenvectors of T, or the products QX and/or QY, where Q is an input matrix. If Q is the unitary factor that reduces a matrix A to Schur form T, then QX and QY are the matrices of right and left eigenvectors of A. This uses a Level 3 BLAS version of the back transformation.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | side | |||
| character, | intent(in) | :: | howmny | |||
| logical(kind=lk), | intent(in) | :: | select(*) | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=sp), | intent(inout) | :: | t(ldt,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldt | |||
| complex(kind=sp), | intent(inout) | :: | vl(ldvl,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldvl | |||
| complex(kind=sp), | intent(inout) | :: | vr(ldvr,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldvr | |||
| integer(kind=ilp), | intent(in) | :: | mm | |||
| integer(kind=ilp), | intent(out) | :: | m | |||
| complex(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| real(kind=sp), | intent(out) | :: | rwork(*) | |||
| integer(kind=ilp), | intent(in) | :: | lrwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
DTREVC3 computes some or all of the right and/or left eigenvectors of a real upper quasi-triangular matrix T. Matrices of this type are produced by the Schur factorization of a real general matrix: A = QTQT, as computed by DHSEQR. The right eigenvector x and the left eigenvector y of T corresponding to an eigenvalue w are defined by: Tx = wx, (yT)T = w(yT) where yT denotes the transpose of the vector y. The eigenvalues are not input to this routine, but are read directly from the diagonal blocks of T. This routine returns the matrices X and/or Y of right and left eigenvectors of T, or the products QX and/or QY, where Q is an input matrix. If Q is the orthogonal factor that reduces a matrix A to Schur form T, then QX and QY are the matrices of right and left eigenvectors of A. This uses a Level 3 BLAS version of the back transformation.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | side | |||
| character, | intent(in) | :: | howmny | |||
| logical(kind=lk), | intent(inout) | :: | select(*) | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=dp), | intent(in) | :: | t(ldt,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldt | |||
| real(kind=dp), | intent(inout) | :: | vl(ldvl,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldvl | |||
| real(kind=dp), | intent(inout) | :: | vr(ldvr,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldvr | |||
| integer(kind=ilp), | intent(in) | :: | mm | |||
| integer(kind=ilp), | intent(out) | :: | m | |||
| real(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
STREVC3 computes some or all of the right and/or left eigenvectors of a real upper quasi-triangular matrix T. Matrices of this type are produced by the Schur factorization of a real general matrix: A = QTQT, as computed by SHSEQR. The right eigenvector x and the left eigenvector y of T corresponding to an eigenvalue w are defined by: Tx = wx, (yT)T = w(yT) where yT denotes the transpose of the vector y. The eigenvalues are not input to this routine, but are read directly from the diagonal blocks of T. This routine returns the matrices X and/or Y of right and left eigenvectors of T, or the products QX and/or QY, where Q is an input matrix. If Q is the orthogonal factor that reduces a matrix A to Schur form T, then QX and QY are the matrices of right and left eigenvectors of A. This uses a Level 3 BLAS version of the back transformation.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | side | |||
| character, | intent(in) | :: | howmny | |||
| logical(kind=lk), | intent(inout) | :: | select(*) | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=sp), | intent(in) | :: | t(ldt,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldt | |||
| real(kind=sp), | intent(inout) | :: | vl(ldvl,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldvl | |||
| real(kind=sp), | intent(inout) | :: | vr(ldvr,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldvr | |||
| integer(kind=ilp), | intent(in) | :: | mm | |||
| integer(kind=ilp), | intent(out) | :: | m | |||
| real(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
ZTREVC3 computes some or all of the right and/or left eigenvectors of a complex upper triangular matrix T. Matrices of this type are produced by the Schur factorization of a complex general matrix: A = QTQH, as computed by ZHSEQR. The right eigenvector x and the left eigenvector y of T corresponding to an eigenvalue w are defined by: Tx = wx, (yH)T = w(yH) where yH denotes the conjugate transpose of the vector y. The eigenvalues are not input to this routine, but are read directly from the diagonal of T. This routine returns the matrices X and/or Y of right and left eigenvectors of T, or the products QX and/or QY, where Q is an input matrix. If Q is the unitary factor that reduces a matrix A to Schur form T, then QX and QY are the matrices of right and left eigenvectors of A. This uses a Level 3 BLAS version of the back transformation.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | side | |||
| character, | intent(in) | :: | howmny | |||
| logical(kind=lk), | intent(in) | :: | select(*) | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=dp), | intent(inout) | :: | t(ldt,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldt | |||
| complex(kind=dp), | intent(inout) | :: | vl(ldvl,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldvl | |||
| complex(kind=dp), | intent(inout) | :: | vr(ldvr,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldvr | |||
| integer(kind=ilp), | intent(in) | :: | mm | |||
| integer(kind=ilp), | intent(out) | :: | m | |||
| complex(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| real(kind=dp), | intent(out) | :: | rwork(*) | |||
| integer(kind=ilp), | intent(in) | :: | lrwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
TREXC reorders the Schur factorization of a complex matrix A = QTQH, so that the diagonal element of T with row index IFST is moved to row ILST. The Schur form T is reordered by a unitary similarity transformation ZHTZ, and optionally the matrix Q of Schur vectors is updated by postmultplying it with Z.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | compq | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=sp), | intent(inout) | :: | t(ldt,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldt | |||
| complex(kind=sp), | intent(inout) | :: | q(ldq,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldq | |||
| integer(kind=ilp), | intent(in) | :: | ifst | |||
| integer(kind=ilp), | intent(in) | :: | ilst | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | compq | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=dp), | intent(inout) | :: | t(ldt,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldt | |||
| real(kind=dp), | intent(inout) | :: | q(ldq,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldq | |||
| integer(kind=ilp), | intent(inout) | :: | ifst | |||
| integer(kind=ilp), | intent(inout) | :: | ilst | |||
| real(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | compq | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=sp), | intent(inout) | :: | t(ldt,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldt | |||
| real(kind=sp), | intent(inout) | :: | q(ldq,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldq | |||
| integer(kind=ilp), | intent(inout) | :: | ifst | |||
| integer(kind=ilp), | intent(inout) | :: | ilst | |||
| real(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | compq | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=dp), | intent(inout) | :: | t(ldt,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldt | |||
| complex(kind=dp), | intent(inout) | :: | q(ldq,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldq | |||
| integer(kind=ilp), | intent(in) | :: | ifst | |||
| integer(kind=ilp), | intent(in) | :: | ilst | |||
| integer(kind=ilp), | intent(out) | :: | info |
CTREXC reorders the Schur factorization of a complex matrix A = QTQH, so that the diagonal element of T with row index IFST is moved to row ILST. The Schur form T is reordered by a unitary similarity transformation ZHTZ, and optionally the matrix Q of Schur vectors is updated by postmultplying it with Z.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | compq | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=sp), | intent(inout) | :: | t(ldt,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldt | |||
| complex(kind=sp), | intent(inout) | :: | q(ldq,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldq | |||
| integer(kind=ilp), | intent(in) | :: | ifst | |||
| integer(kind=ilp), | intent(in) | :: | ilst | |||
| integer(kind=ilp), | intent(out) | :: | info |
DTREXC reorders the real Schur factorization of a real matrix A = QTQT, so that the diagonal block of T with row index IFST is moved to row ILST. The real Schur form T is reordered by an orthogonal similarity transformation ZTTZ, and optionally the matrix Q of Schur vectors is updated by postmultiplying it with Z. T must be in Schur canonical form (as returned by DHSEQR), that is, block upper triangular with 1-by-1 and 2-by-2 diagonal blocks; each 2-by-2 diagonal block has its diagonal elements equal and its off-diagonal elements of opposite sign.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | compq | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=dp), | intent(inout) | :: | t(ldt,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldt | |||
| real(kind=dp), | intent(inout) | :: | q(ldq,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldq | |||
| integer(kind=ilp), | intent(inout) | :: | ifst | |||
| integer(kind=ilp), | intent(inout) | :: | ilst | |||
| real(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
STREXC reorders the real Schur factorization of a real matrix A = QTQT, so that the diagonal block of T with row index IFST is moved to row ILST. The real Schur form T is reordered by an orthogonal similarity transformation ZTTZ, and optionally the matrix Q of Schur vectors is updated by postmultiplying it with Z. T must be in Schur canonical form (as returned by SHSEQR), that is, block upper triangular with 1-by-1 and 2-by-2 diagonal blocks; each 2-by-2 diagonal block has its diagonal elements equal and its off-diagonal elements of opposite sign.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | compq | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=sp), | intent(inout) | :: | t(ldt,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldt | |||
| real(kind=sp), | intent(inout) | :: | q(ldq,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldq | |||
| integer(kind=ilp), | intent(inout) | :: | ifst | |||
| integer(kind=ilp), | intent(inout) | :: | ilst | |||
| real(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
ZTREXC reorders the Schur factorization of a complex matrix A = QTQH, so that the diagonal element of T with row index IFST is moved to row ILST. The Schur form T is reordered by a unitary similarity transformation ZHTZ, and optionally the matrix Q of Schur vectors is updated by postmultplying it with Z.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | compq | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=dp), | intent(inout) | :: | t(ldt,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldt | |||
| complex(kind=dp), | intent(inout) | :: | q(ldq,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldq | |||
| integer(kind=ilp), | intent(in) | :: | ifst | |||
| integer(kind=ilp), | intent(in) | :: | ilst | |||
| integer(kind=ilp), | intent(out) | :: | info |
TRRFS provides error bounds and backward error estimates for the solution to a system of linear equations with a triangular coefficient matrix. The solution matrix X must be computed by CTRTRS or some other means before entering this routine. TRRFS does not do iterative refinement because doing so cannot improve the backward error.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| character, | intent(in) | :: | trans | |||
| character, | intent(in) | :: | diag | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| complex(kind=sp), | intent(in) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=sp), | intent(in) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| complex(kind=sp), | intent(in) | :: | x(ldx,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldx | |||
| real(kind=sp), | intent(out) | :: | ferr(*) | |||
| real(kind=sp), | intent(out) | :: | berr(*) | |||
| complex(kind=sp), | intent(out) | :: | work(*) | |||
| real(kind=sp), | intent(out) | :: | rwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| character, | intent(in) | :: | trans | |||
| character, | intent(in) | :: | diag | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| real(kind=dp), | intent(in) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=dp), | intent(in) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| real(kind=dp), | intent(in) | :: | x(ldx,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldx | |||
| real(kind=dp), | intent(out) | :: | ferr(*) | |||
| real(kind=dp), | intent(out) | :: | berr(*) | |||
| real(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | iwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| character, | intent(in) | :: | trans | |||
| character, | intent(in) | :: | diag | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| real(kind=sp), | intent(in) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=sp), | intent(in) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| real(kind=sp), | intent(in) | :: | x(ldx,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldx | |||
| real(kind=sp), | intent(out) | :: | ferr(*) | |||
| real(kind=sp), | intent(out) | :: | berr(*) | |||
| real(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | iwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| character, | intent(in) | :: | trans | |||
| character, | intent(in) | :: | diag | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| complex(kind=dp), | intent(in) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=dp), | intent(in) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| complex(kind=dp), | intent(in) | :: | x(ldx,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldx | |||
| real(kind=dp), | intent(out) | :: | ferr(*) | |||
| real(kind=dp), | intent(out) | :: | berr(*) | |||
| complex(kind=dp), | intent(out) | :: | work(*) | |||
| real(kind=dp), | intent(out) | :: | rwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
CTRRFS provides error bounds and backward error estimates for the solution to a system of linear equations with a triangular coefficient matrix. The solution matrix X must be computed by CTRTRS or some other means before entering this routine. CTRRFS does not do iterative refinement because doing so cannot improve the backward error.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| character, | intent(in) | :: | trans | |||
| character, | intent(in) | :: | diag | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| complex(kind=sp), | intent(in) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=sp), | intent(in) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| complex(kind=sp), | intent(in) | :: | x(ldx,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldx | |||
| real(kind=sp), | intent(out) | :: | ferr(*) | |||
| real(kind=sp), | intent(out) | :: | berr(*) | |||
| complex(kind=sp), | intent(out) | :: | work(*) | |||
| real(kind=sp), | intent(out) | :: | rwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
DTRRFS provides error bounds and backward error estimates for the solution to a system of linear equations with a triangular coefficient matrix. The solution matrix X must be computed by DTRTRS or some other means before entering this routine. DTRRFS does not do iterative refinement because doing so cannot improve the backward error.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| character, | intent(in) | :: | trans | |||
| character, | intent(in) | :: | diag | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| real(kind=dp), | intent(in) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=dp), | intent(in) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| real(kind=dp), | intent(in) | :: | x(ldx,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldx | |||
| real(kind=dp), | intent(out) | :: | ferr(*) | |||
| real(kind=dp), | intent(out) | :: | berr(*) | |||
| real(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | iwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
STRRFS provides error bounds and backward error estimates for the solution to a system of linear equations with a triangular coefficient matrix. The solution matrix X must be computed by STRTRS or some other means before entering this routine. STRRFS does not do iterative refinement because doing so cannot improve the backward error.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| character, | intent(in) | :: | trans | |||
| character, | intent(in) | :: | diag | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| real(kind=sp), | intent(in) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=sp), | intent(in) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| real(kind=sp), | intent(in) | :: | x(ldx,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldx | |||
| real(kind=sp), | intent(out) | :: | ferr(*) | |||
| real(kind=sp), | intent(out) | :: | berr(*) | |||
| real(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | iwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
ZTRRFS provides error bounds and backward error estimates for the solution to a system of linear equations with a triangular coefficient matrix. The solution matrix X must be computed by ZTRTRS or some other means before entering this routine. ZTRRFS does not do iterative refinement because doing so cannot improve the backward error.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| character, | intent(in) | :: | trans | |||
| character, | intent(in) | :: | diag | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| complex(kind=dp), | intent(in) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=dp), | intent(in) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| complex(kind=dp), | intent(in) | :: | x(ldx,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldx | |||
| real(kind=dp), | intent(out) | :: | ferr(*) | |||
| real(kind=dp), | intent(out) | :: | berr(*) | |||
| complex(kind=dp), | intent(out) | :: | work(*) | |||
| real(kind=dp), | intent(out) | :: | rwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
TRSEN reorders the Schur factorization of a complex matrix A = QTQ**H, so that a selected cluster of eigenvalues appears in the leading positions on the diagonal of the upper triangular matrix T, and the leading columns of Q form an orthonormal basis of the corresponding right invariant subspace. Optionally the routine computes the reciprocal condition numbers of the cluster of eigenvalues and/or the invariant subspace.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | job | |||
| character, | intent(in) | :: | compq | |||
| logical(kind=lk), | intent(in) | :: | select(*) | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=sp), | intent(inout) | :: | t(ldt,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldt | |||
| complex(kind=sp), | intent(inout) | :: | q(ldq,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldq | |||
| complex(kind=sp), | intent(out) | :: | w(*) | |||
| integer(kind=ilp), | intent(out) | :: | m | |||
| real(kind=sp), | intent(out) | :: | s | |||
| real(kind=sp), | intent(out) | :: | sep | |||
| complex(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | job | |||
| character, | intent(in) | :: | compq | |||
| logical(kind=lk), | intent(in) | :: | select(*) | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=dp), | intent(inout) | :: | t(ldt,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldt | |||
| real(kind=dp), | intent(inout) | :: | q(ldq,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldq | |||
| real(kind=dp), | intent(out) | :: | wr(*) | |||
| real(kind=dp), | intent(out) | :: | wi(*) | |||
| integer(kind=ilp), | intent(out) | :: | m | |||
| real(kind=dp), | intent(out) | :: | s | |||
| real(kind=dp), | intent(out) | :: | sep | |||
| real(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | iwork(*) | |||
| integer(kind=ilp), | intent(in) | :: | liwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | job | |||
| character, | intent(in) | :: | compq | |||
| logical(kind=lk), | intent(in) | :: | select(*) | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=sp), | intent(inout) | :: | t(ldt,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldt | |||
| real(kind=sp), | intent(inout) | :: | q(ldq,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldq | |||
| real(kind=sp), | intent(out) | :: | wr(*) | |||
| real(kind=sp), | intent(out) | :: | wi(*) | |||
| integer(kind=ilp), | intent(out) | :: | m | |||
| real(kind=sp), | intent(out) | :: | s | |||
| real(kind=sp), | intent(out) | :: | sep | |||
| real(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | iwork(*) | |||
| integer(kind=ilp), | intent(in) | :: | liwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | job | |||
| character, | intent(in) | :: | compq | |||
| logical(kind=lk), | intent(in) | :: | select(*) | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=dp), | intent(inout) | :: | t(ldt,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldt | |||
| complex(kind=dp), | intent(inout) | :: | q(ldq,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldq | |||
| complex(kind=dp), | intent(out) | :: | w(*) | |||
| integer(kind=ilp), | intent(out) | :: | m | |||
| real(kind=dp), | intent(out) | :: | s | |||
| real(kind=dp), | intent(out) | :: | sep | |||
| complex(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
CTRSEN reorders the Schur factorization of a complex matrix A = QTQ**H, so that a selected cluster of eigenvalues appears in the leading positions on the diagonal of the upper triangular matrix T, and the leading columns of Q form an orthonormal basis of the corresponding right invariant subspace. Optionally the routine computes the reciprocal condition numbers of the cluster of eigenvalues and/or the invariant subspace.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | job | |||
| character, | intent(in) | :: | compq | |||
| logical(kind=lk), | intent(in) | :: | select(*) | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=sp), | intent(inout) | :: | t(ldt,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldt | |||
| complex(kind=sp), | intent(inout) | :: | q(ldq,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldq | |||
| complex(kind=sp), | intent(out) | :: | w(*) | |||
| integer(kind=ilp), | intent(out) | :: | m | |||
| real(kind=sp), | intent(out) | :: | s | |||
| real(kind=sp), | intent(out) | :: | sep | |||
| complex(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
DTRSEN reorders the real Schur factorization of a real matrix A = QTQ**T, so that a selected cluster of eigenvalues appears in the leading diagonal blocks of the upper quasi-triangular matrix T, and the leading columns of Q form an orthonormal basis of the corresponding right invariant subspace. Optionally the routine computes the reciprocal condition numbers of the cluster of eigenvalues and/or the invariant subspace. T must be in Schur canonical form (as returned by DHSEQR), that is, block upper triangular with 1-by-1 and 2-by-2 diagonal blocks; each 2-by-2 diagonal block has its diagonal elements equal and its off-diagonal elements of opposite sign.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | job | |||
| character, | intent(in) | :: | compq | |||
| logical(kind=lk), | intent(in) | :: | select(*) | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=dp), | intent(inout) | :: | t(ldt,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldt | |||
| real(kind=dp), | intent(inout) | :: | q(ldq,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldq | |||
| real(kind=dp), | intent(out) | :: | wr(*) | |||
| real(kind=dp), | intent(out) | :: | wi(*) | |||
| integer(kind=ilp), | intent(out) | :: | m | |||
| real(kind=dp), | intent(out) | :: | s | |||
| real(kind=dp), | intent(out) | :: | sep | |||
| real(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | iwork(*) | |||
| integer(kind=ilp), | intent(in) | :: | liwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
STRSEN reorders the real Schur factorization of a real matrix A = QTQ**T, so that a selected cluster of eigenvalues appears in the leading diagonal blocks of the upper quasi-triangular matrix T, and the leading columns of Q form an orthonormal basis of the corresponding right invariant subspace. Optionally the routine computes the reciprocal condition numbers of the cluster of eigenvalues and/or the invariant subspace. T must be in Schur canonical form (as returned by SHSEQR), that is, block upper triangular with 1-by-1 and 2-by-2 diagonal blocks; each 2-by-2 diagonal block has its diagonal elements equal and its off-diagonal elements of opposite sign.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | job | |||
| character, | intent(in) | :: | compq | |||
| logical(kind=lk), | intent(in) | :: | select(*) | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=sp), | intent(inout) | :: | t(ldt,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldt | |||
| real(kind=sp), | intent(inout) | :: | q(ldq,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldq | |||
| real(kind=sp), | intent(out) | :: | wr(*) | |||
| real(kind=sp), | intent(out) | :: | wi(*) | |||
| integer(kind=ilp), | intent(out) | :: | m | |||
| real(kind=sp), | intent(out) | :: | s | |||
| real(kind=sp), | intent(out) | :: | sep | |||
| real(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | iwork(*) | |||
| integer(kind=ilp), | intent(in) | :: | liwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
ZTRSEN reorders the Schur factorization of a complex matrix A = QTQ**H, so that a selected cluster of eigenvalues appears in the leading positions on the diagonal of the upper triangular matrix T, and the leading columns of Q form an orthonormal basis of the corresponding right invariant subspace. Optionally the routine computes the reciprocal condition numbers of the cluster of eigenvalues and/or the invariant subspace.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | job | |||
| character, | intent(in) | :: | compq | |||
| logical(kind=lk), | intent(in) | :: | select(*) | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=dp), | intent(inout) | :: | t(ldt,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldt | |||
| complex(kind=dp), | intent(inout) | :: | q(ldq,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldq | |||
| complex(kind=dp), | intent(out) | :: | w(*) | |||
| integer(kind=ilp), | intent(out) | :: | m | |||
| real(kind=dp), | intent(out) | :: | s | |||
| real(kind=dp), | intent(out) | :: | sep | |||
| complex(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
TRSNA estimates reciprocal condition numbers for specified eigenvalues and/or right eigenvectors of a complex upper triangular matrix T (or of any matrix QTQ**H with Q unitary).
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | job | |||
| character, | intent(in) | :: | howmny | |||
| logical(kind=lk), | intent(in) | :: | select(*) | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=sp), | intent(in) | :: | t(ldt,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldt | |||
| complex(kind=sp), | intent(in) | :: | vl(ldvl,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldvl | |||
| complex(kind=sp), | intent(in) | :: | vr(ldvr,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldvr | |||
| real(kind=sp), | intent(out) | :: | s(*) | |||
| real(kind=sp), | intent(out) | :: | sep(*) | |||
| integer(kind=ilp), | intent(in) | :: | mm | |||
| integer(kind=ilp), | intent(out) | :: | m | |||
| complex(kind=sp), | intent(out) | :: | work(ldwork,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldwork | |||
| real(kind=sp), | intent(out) | :: | rwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | job | |||
| character, | intent(in) | :: | howmny | |||
| logical(kind=lk), | intent(in) | :: | select(*) | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=dp), | intent(in) | :: | t(ldt,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldt | |||
| real(kind=dp), | intent(in) | :: | vl(ldvl,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldvl | |||
| real(kind=dp), | intent(in) | :: | vr(ldvr,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldvr | |||
| real(kind=dp), | intent(out) | :: | s(*) | |||
| real(kind=dp), | intent(out) | :: | sep(*) | |||
| integer(kind=ilp), | intent(in) | :: | mm | |||
| integer(kind=ilp), | intent(out) | :: | m | |||
| real(kind=dp), | intent(out) | :: | work(ldwork,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldwork | |||
| integer(kind=ilp), | intent(out) | :: | iwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | job | |||
| character, | intent(in) | :: | howmny | |||
| logical(kind=lk), | intent(in) | :: | select(*) | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=sp), | intent(in) | :: | t(ldt,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldt | |||
| real(kind=sp), | intent(in) | :: | vl(ldvl,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldvl | |||
| real(kind=sp), | intent(in) | :: | vr(ldvr,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldvr | |||
| real(kind=sp), | intent(out) | :: | s(*) | |||
| real(kind=sp), | intent(out) | :: | sep(*) | |||
| integer(kind=ilp), | intent(in) | :: | mm | |||
| integer(kind=ilp), | intent(out) | :: | m | |||
| real(kind=sp), | intent(out) | :: | work(ldwork,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldwork | |||
| integer(kind=ilp), | intent(out) | :: | iwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | job | |||
| character, | intent(in) | :: | howmny | |||
| logical(kind=lk), | intent(in) | :: | select(*) | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=dp), | intent(in) | :: | t(ldt,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldt | |||
| complex(kind=dp), | intent(in) | :: | vl(ldvl,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldvl | |||
| complex(kind=dp), | intent(in) | :: | vr(ldvr,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldvr | |||
| real(kind=dp), | intent(out) | :: | s(*) | |||
| real(kind=dp), | intent(out) | :: | sep(*) | |||
| integer(kind=ilp), | intent(in) | :: | mm | |||
| integer(kind=ilp), | intent(out) | :: | m | |||
| complex(kind=dp), | intent(out) | :: | work(ldwork,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldwork | |||
| real(kind=dp), | intent(out) | :: | rwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
CTRSNA estimates reciprocal condition numbers for specified eigenvalues and/or right eigenvectors of a complex upper triangular matrix T (or of any matrix QTQ**H with Q unitary).
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | job | |||
| character, | intent(in) | :: | howmny | |||
| logical(kind=lk), | intent(in) | :: | select(*) | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=sp), | intent(in) | :: | t(ldt,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldt | |||
| complex(kind=sp), | intent(in) | :: | vl(ldvl,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldvl | |||
| complex(kind=sp), | intent(in) | :: | vr(ldvr,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldvr | |||
| real(kind=sp), | intent(out) | :: | s(*) | |||
| real(kind=sp), | intent(out) | :: | sep(*) | |||
| integer(kind=ilp), | intent(in) | :: | mm | |||
| integer(kind=ilp), | intent(out) | :: | m | |||
| complex(kind=sp), | intent(out) | :: | work(ldwork,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldwork | |||
| real(kind=sp), | intent(out) | :: | rwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
DTRSNA estimates reciprocal condition numbers for specified eigenvalues and/or right eigenvectors of a real upper quasi-triangular matrix T (or of any matrix QTQ**T with Q orthogonal). T must be in Schur canonical form (as returned by DHSEQR), that is, block upper triangular with 1-by-1 and 2-by-2 diagonal blocks; each 2-by-2 diagonal block has its diagonal elements equal and its off-diagonal elements of opposite sign.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | job | |||
| character, | intent(in) | :: | howmny | |||
| logical(kind=lk), | intent(in) | :: | select(*) | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=dp), | intent(in) | :: | t(ldt,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldt | |||
| real(kind=dp), | intent(in) | :: | vl(ldvl,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldvl | |||
| real(kind=dp), | intent(in) | :: | vr(ldvr,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldvr | |||
| real(kind=dp), | intent(out) | :: | s(*) | |||
| real(kind=dp), | intent(out) | :: | sep(*) | |||
| integer(kind=ilp), | intent(in) | :: | mm | |||
| integer(kind=ilp), | intent(out) | :: | m | |||
| real(kind=dp), | intent(out) | :: | work(ldwork,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldwork | |||
| integer(kind=ilp), | intent(out) | :: | iwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
STRSNA estimates reciprocal condition numbers for specified eigenvalues and/or right eigenvectors of a real upper quasi-triangular matrix T (or of any matrix QTQ**T with Q orthogonal). T must be in Schur canonical form (as returned by SHSEQR), that is, block upper triangular with 1-by-1 and 2-by-2 diagonal blocks; each 2-by-2 diagonal block has its diagonal elements equal and its off-diagonal elements of opposite sign.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | job | |||
| character, | intent(in) | :: | howmny | |||
| logical(kind=lk), | intent(in) | :: | select(*) | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=sp), | intent(in) | :: | t(ldt,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldt | |||
| real(kind=sp), | intent(in) | :: | vl(ldvl,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldvl | |||
| real(kind=sp), | intent(in) | :: | vr(ldvr,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldvr | |||
| real(kind=sp), | intent(out) | :: | s(*) | |||
| real(kind=sp), | intent(out) | :: | sep(*) | |||
| integer(kind=ilp), | intent(in) | :: | mm | |||
| integer(kind=ilp), | intent(out) | :: | m | |||
| real(kind=sp), | intent(out) | :: | work(ldwork,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldwork | |||
| integer(kind=ilp), | intent(out) | :: | iwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
ZTRSNA estimates reciprocal condition numbers for specified eigenvalues and/or right eigenvectors of a complex upper triangular matrix T (or of any matrix QTQ**H with Q unitary).
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | job | |||
| character, | intent(in) | :: | howmny | |||
| logical(kind=lk), | intent(in) | :: | select(*) | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=dp), | intent(in) | :: | t(ldt,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldt | |||
| complex(kind=dp), | intent(in) | :: | vl(ldvl,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldvl | |||
| complex(kind=dp), | intent(in) | :: | vr(ldvr,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldvr | |||
| real(kind=dp), | intent(out) | :: | s(*) | |||
| real(kind=dp), | intent(out) | :: | sep(*) | |||
| integer(kind=ilp), | intent(in) | :: | mm | |||
| integer(kind=ilp), | intent(out) | :: | m | |||
| complex(kind=dp), | intent(out) | :: | work(ldwork,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldwork | |||
| real(kind=dp), | intent(out) | :: | rwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
TRSYL solves the complex Sylvester matrix equation: op(A)X + Xop(B) = scaleC or op(A)X - Xop(B) = scaleC, where op(A) = A or A**H, and A and B are both upper triangular. A is M-by-M and B is N-by-N; the right hand side C and the solution X are M-by-N; and scale is an output scale factor, set <= 1 to avoid overflow in X.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | trana | |||
| character, | intent(in) | :: | tranb | |||
| integer(kind=ilp), | intent(in) | :: | isgn | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=sp), | intent(in) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=sp), | intent(in) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| complex(kind=sp), | intent(inout) | :: | c(ldc,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldc | |||
| real(kind=sp), | intent(out) | :: | scale | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | trana | |||
| character, | intent(in) | :: | tranb | |||
| integer(kind=ilp), | intent(in) | :: | isgn | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=dp), | intent(in) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=dp), | intent(in) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| real(kind=dp), | intent(inout) | :: | c(ldc,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldc | |||
| real(kind=dp), | intent(out) | :: | scale | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | trana | |||
| character, | intent(in) | :: | tranb | |||
| integer(kind=ilp), | intent(in) | :: | isgn | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=sp), | intent(in) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=sp), | intent(in) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| real(kind=sp), | intent(inout) | :: | c(ldc,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldc | |||
| real(kind=sp), | intent(out) | :: | scale | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | trana | |||
| character, | intent(in) | :: | tranb | |||
| integer(kind=ilp), | intent(in) | :: | isgn | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=dp), | intent(in) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=dp), | intent(in) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| complex(kind=dp), | intent(inout) | :: | c(ldc,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldc | |||
| real(kind=dp), | intent(out) | :: | scale | |||
| integer(kind=ilp), | intent(out) | :: | info |
CTRSYL solves the complex Sylvester matrix equation: op(A)X + Xop(B) = scaleC or op(A)X - Xop(B) = scaleC, where op(A) = A or A**H, and A and B are both upper triangular. A is M-by-M and B is N-by-N; the right hand side C and the solution X are M-by-N; and scale is an output scale factor, set <= 1 to avoid overflow in X.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | trana | |||
| character, | intent(in) | :: | tranb | |||
| integer(kind=ilp), | intent(in) | :: | isgn | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=sp), | intent(in) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=sp), | intent(in) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| complex(kind=sp), | intent(inout) | :: | c(ldc,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldc | |||
| real(kind=sp), | intent(out) | :: | scale | |||
| integer(kind=ilp), | intent(out) | :: | info |
DTRSYL solves the real Sylvester matrix equation: op(A)X + Xop(B) = scaleC or op(A)X - Xop(B) = scaleC, where op(A) = A or A**T, and A and B are both upper quasi- triangular. A is M-by-M and B is N-by-N; the right hand side C and the solution X are M-by-N; and scale is an output scale factor, set <= 1 to avoid overflow in X. A and B must be in Schur canonical form (as returned by DHSEQR), that is, block upper triangular with 1-by-1 and 2-by-2 diagonal blocks; each 2-by-2 diagonal block has its diagonal elements equal and its off-diagonal elements of opposite sign.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | trana | |||
| character, | intent(in) | :: | tranb | |||
| integer(kind=ilp), | intent(in) | :: | isgn | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=dp), | intent(in) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=dp), | intent(in) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| real(kind=dp), | intent(inout) | :: | c(ldc,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldc | |||
| real(kind=dp), | intent(out) | :: | scale | |||
| integer(kind=ilp), | intent(out) | :: | info |
STRSYL solves the real Sylvester matrix equation: op(A)X + Xop(B) = scaleC or op(A)X - Xop(B) = scaleC, where op(A) = A or A**T, and A and B are both upper quasi- triangular. A is M-by-M and B is N-by-N; the right hand side C and the solution X are M-by-N; and scale is an output scale factor, set <= 1 to avoid overflow in X. A and B must be in Schur canonical form (as returned by SHSEQR), that is, block upper triangular with 1-by-1 and 2-by-2 diagonal blocks; each 2-by-2 diagonal block has its diagonal elements equal and its off-diagonal elements of opposite sign.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | trana | |||
| character, | intent(in) | :: | tranb | |||
| integer(kind=ilp), | intent(in) | :: | isgn | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=sp), | intent(in) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=sp), | intent(in) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| real(kind=sp), | intent(inout) | :: | c(ldc,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldc | |||
| real(kind=sp), | intent(out) | :: | scale | |||
| integer(kind=ilp), | intent(out) | :: | info |
ZTRSYL solves the complex Sylvester matrix equation: op(A)X + Xop(B) = scaleC or op(A)X - Xop(B) = scaleC, where op(A) = A or A**H, and A and B are both upper triangular. A is M-by-M and B is N-by-N; the right hand side C and the solution X are M-by-N; and scale is an output scale factor, set <= 1 to avoid overflow in X.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | trana | |||
| character, | intent(in) | :: | tranb | |||
| integer(kind=ilp), | intent(in) | :: | isgn | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=dp), | intent(in) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=dp), | intent(in) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| complex(kind=dp), | intent(inout) | :: | c(ldc,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldc | |||
| real(kind=dp), | intent(out) | :: | scale | |||
| integer(kind=ilp), | intent(out) | :: | info |
TRTRI computes the inverse of a complex upper or lower triangular matrix A. This is the Level 3 BLAS version of the algorithm.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| character, | intent(in) | :: | diag | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| character, | intent(in) | :: | diag | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| character, | intent(in) | :: | diag | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| character, | intent(in) | :: | diag | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| integer(kind=ilp), | intent(out) | :: | info |
CTRTRI computes the inverse of a complex upper or lower triangular matrix A. This is the Level 3 BLAS version of the algorithm.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| character, | intent(in) | :: | diag | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| integer(kind=ilp), | intent(out) | :: | info |
DTRTRI computes the inverse of a real upper or lower triangular matrix A. This is the Level 3 BLAS version of the algorithm.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| character, | intent(in) | :: | diag | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| integer(kind=ilp), | intent(out) | :: | info |
STRTRI computes the inverse of a real upper or lower triangular matrix A. This is the Level 3 BLAS version of the algorithm.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| character, | intent(in) | :: | diag | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| integer(kind=ilp), | intent(out) | :: | info |
ZTRTRI computes the inverse of a complex upper or lower triangular matrix A. This is the Level 3 BLAS version of the algorithm.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| character, | intent(in) | :: | diag | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| integer(kind=ilp), | intent(out) | :: | info |
TRTRS solves a triangular system of the form A * X = B, AT * X = B, or AH * X = B, where A is a triangular matrix of order N, and B is an N-by-NRHS matrix. A check is made to verify that A is nonsingular.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| character, | intent(in) | :: | trans | |||
| character, | intent(in) | :: | diag | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| complex(kind=sp), | intent(in) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=sp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| character, | intent(in) | :: | trans | |||
| character, | intent(in) | :: | diag | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| real(kind=dp), | intent(in) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=dp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| character, | intent(in) | :: | trans | |||
| character, | intent(in) | :: | diag | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| real(kind=sp), | intent(in) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=sp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| character, | intent(in) | :: | trans | |||
| character, | intent(in) | :: | diag | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| complex(kind=dp), | intent(in) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=dp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| integer(kind=ilp), | intent(out) | :: | info |
CTRTRS solves a triangular system of the form A * X = B, AT * X = B, or AH * X = B, where A is a triangular matrix of order N, and B is an N-by-NRHS matrix. A check is made to verify that A is nonsingular.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| character, | intent(in) | :: | trans | |||
| character, | intent(in) | :: | diag | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| complex(kind=sp), | intent(in) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=sp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| integer(kind=ilp), | intent(out) | :: | info |
DTRTRS solves a triangular system of the form A * X = B or A**T * X = B, where A is a triangular matrix of order N, and B is an N-by-NRHS matrix. A check is made to verify that A is nonsingular.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| character, | intent(in) | :: | trans | |||
| character, | intent(in) | :: | diag | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| real(kind=dp), | intent(in) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=dp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| integer(kind=ilp), | intent(out) | :: | info |
STRTRS solves a triangular system of the form A * X = B or A**T * X = B, where A is a triangular matrix of order N, and B is an N-by-NRHS matrix. A check is made to verify that A is nonsingular.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| character, | intent(in) | :: | trans | |||
| character, | intent(in) | :: | diag | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| real(kind=sp), | intent(in) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=sp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| integer(kind=ilp), | intent(out) | :: | info |
ZTRTRS solves a triangular system of the form A * X = B, AT * X = B, or AH * X = B, where A is a triangular matrix of order N, and B is an N-by-NRHS matrix. A check is made to verify that A is nonsingular.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| character, | intent(in) | :: | trans | |||
| character, | intent(in) | :: | diag | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nrhs | |||
| complex(kind=dp), | intent(in) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=dp), | intent(inout) | :: | b(ldb,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldb | |||
| integer(kind=ilp), | intent(out) | :: | info |
TRTTF copies a triangular matrix A from standard full format (TR) to rectangular full packed format (TF) .
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | transr | |||
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=sp), | intent(in) | :: | a(0:lda-1,0:*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=sp), | intent(out) | :: | arf(0:*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | transr | |||
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=dp), | intent(in) | :: | a(0:lda-1,0:*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=dp), | intent(out) | :: | arf(0:*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | transr | |||
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=sp), | intent(in) | :: | a(0:lda-1,0:*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=sp), | intent(out) | :: | arf(0:*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | transr | |||
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=dp), | intent(in) | :: | a(0:lda-1,0:*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=dp), | intent(out) | :: | arf(0:*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
CTRTTF copies a triangular matrix A from standard full format (TR) to rectangular full packed format (TF) .
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | transr | |||
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=sp), | intent(in) | :: | a(0:lda-1,0:*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=sp), | intent(out) | :: | arf(0:*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
DTRTTF copies a triangular matrix A from standard full format (TR) to rectangular full packed format (TF) .
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | transr | |||
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=dp), | intent(in) | :: | a(0:lda-1,0:*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=dp), | intent(out) | :: | arf(0:*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
STRTTF copies a triangular matrix A from standard full format (TR) to rectangular full packed format (TF) .
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | transr | |||
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=sp), | intent(in) | :: | a(0:lda-1,0:*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=sp), | intent(out) | :: | arf(0:*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
ZTRTTF copies a triangular matrix A from standard full format (TR) to rectangular full packed format (TF) .
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | transr | |||
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=dp), | intent(in) | :: | a(0:lda-1,0:*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=dp), | intent(out) | :: | arf(0:*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
TRTTP copies a triangular matrix A from full format (TR) to standard packed format (TP).
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=sp), | intent(in) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=sp), | intent(out) | :: | ap(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=dp), | intent(in) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=dp), | intent(out) | :: | ap(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=sp), | intent(in) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=sp), | intent(out) | :: | ap(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=dp), | intent(in) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=dp), | intent(out) | :: | ap(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
CTRTTP copies a triangular matrix A from full format (TR) to standard packed format (TP).
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=sp), | intent(in) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=sp), | intent(out) | :: | ap(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
DTRTTP copies a triangular matrix A from full format (TR) to standard packed format (TP).
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=dp), | intent(in) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=dp), | intent(out) | :: | ap(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
STRTTP copies a triangular matrix A from full format (TR) to standard packed format (TP).
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=sp), | intent(in) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=sp), | intent(out) | :: | ap(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
ZTRTTP copies a triangular matrix A from full format (TR) to standard packed format (TP).
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=dp), | intent(in) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=dp), | intent(out) | :: | ap(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
TZRZF reduces the M-by-N ( M<=N ) complex upper trapezoidal matrix A to upper triangular form by means of unitary transformations. The upper trapezoidal matrix A is factored as A = ( R 0 ) * Z, where Z is an N-by-N unitary matrix and R is an M-by-M upper triangular matrix.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=sp), | intent(out) | :: | tau(*) | |||
| complex(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=dp), | intent(out) | :: | tau(*) | |||
| real(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=sp), | intent(out) | :: | tau(*) | |||
| real(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=dp), | intent(out) | :: | tau(*) | |||
| complex(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
CTZRZF reduces the M-by-N ( M<=N ) complex upper trapezoidal matrix A to upper triangular form by means of unitary transformations. The upper trapezoidal matrix A is factored as A = ( R 0 ) * Z, where Z is an N-by-N unitary matrix and R is an M-by-M upper triangular matrix.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=sp), | intent(out) | :: | tau(*) | |||
| complex(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
DTZRZF reduces the M-by-N ( M<=N ) real upper trapezoidal matrix A to upper triangular form by means of orthogonal transformations. The upper trapezoidal matrix A is factored as A = ( R 0 ) * Z, where Z is an N-by-N orthogonal matrix and R is an M-by-M upper triangular matrix.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=dp), | intent(out) | :: | tau(*) | |||
| real(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
STZRZF reduces the M-by-N ( M<=N ) real upper trapezoidal matrix A to upper triangular form by means of orthogonal transformations. The upper trapezoidal matrix A is factored as A = ( R 0 ) * Z, where Z is an N-by-N orthogonal matrix and R is an M-by-M upper triangular matrix.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| real(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| real(kind=sp), | intent(out) | :: | tau(*) | |||
| real(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
ZTZRZF reduces the M-by-N ( M<=N ) complex upper trapezoidal matrix A to upper triangular form by means of unitary transformations. The upper trapezoidal matrix A is factored as A = ( R 0 ) * Z, where Z is an N-by-N unitary matrix and R is an M-by-M upper triangular matrix.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=dp), | intent(out) | :: | tau(*) | |||
| complex(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
UNBDB simultaneously bidiagonalizes the blocks of an M-by-M partitioned unitary matrix X: [ B11 | B12 0 0 ] [ X11 | X12 ] [ P1 | ] [ 0 | 0 -I 0 ] [ Q1 | ]**H X = [-----------] = [---------] [----------------] [---------] . [ X21 | X22 ] [ | P2 ] [ B21 | B22 0 0 ] [ | Q2 ] [ 0 | 0 0 I ] X11 is P-by-Q. Q must be no larger than P, M-P, or M-Q. (If this is not the case, then X must be transposed and/or permuted. This can be done in constant time using the TRANS and SIGNS options. See CUNCSD for details.) The unitary matrices P1, P2, Q1, and Q2 are P-by-P, (M-P)-by- (M-P), Q-by-Q, and (M-Q)-by-(M-Q), respectively. They are represented implicitly by Householder vectors. B11, B12, B21, and B22 are Q-by-Q bidiagonal matrices represented implicitly by angles THETA, PHI.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | trans | |||
| character, | intent(in) | :: | signs | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | p | |||
| integer(kind=ilp), | intent(in) | :: | q | |||
| complex(kind=sp), | intent(inout) | :: | x11(ldx11,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldx11 | |||
| complex(kind=sp), | intent(inout) | :: | x12(ldx12,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldx12 | |||
| complex(kind=sp), | intent(inout) | :: | x21(ldx21,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldx21 | |||
| complex(kind=sp), | intent(inout) | :: | x22(ldx22,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldx22 | |||
| real(kind=sp), | intent(out) | :: | theta(*) | |||
| real(kind=sp), | intent(out) | :: | phi(*) | |||
| complex(kind=sp), | intent(out) | :: | taup1(*) | |||
| complex(kind=sp), | intent(out) | :: | taup2(*) | |||
| complex(kind=sp), | intent(out) | :: | tauq1(*) | |||
| complex(kind=sp), | intent(out) | :: | tauq2(*) | |||
| complex(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | trans | |||
| character, | intent(in) | :: | signs | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | p | |||
| integer(kind=ilp), | intent(in) | :: | q | |||
| complex(kind=dp), | intent(inout) | :: | x11(ldx11,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldx11 | |||
| complex(kind=dp), | intent(inout) | :: | x12(ldx12,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldx12 | |||
| complex(kind=dp), | intent(inout) | :: | x21(ldx21,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldx21 | |||
| complex(kind=dp), | intent(inout) | :: | x22(ldx22,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldx22 | |||
| real(kind=dp), | intent(out) | :: | theta(*) | |||
| real(kind=dp), | intent(out) | :: | phi(*) | |||
| complex(kind=dp), | intent(out) | :: | taup1(*) | |||
| complex(kind=dp), | intent(out) | :: | taup2(*) | |||
| complex(kind=dp), | intent(out) | :: | tauq1(*) | |||
| complex(kind=dp), | intent(out) | :: | tauq2(*) | |||
| complex(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
CUNBDB simultaneously bidiagonalizes the blocks of an M-by-M partitioned unitary matrix X: [ B11 | B12 0 0 ] [ X11 | X12 ] [ P1 | ] [ 0 | 0 -I 0 ] [ Q1 | ]**H X = [-----------] = [---------] [----------------] [---------] . [ X21 | X22 ] [ | P2 ] [ B21 | B22 0 0 ] [ | Q2 ] [ 0 | 0 0 I ] X11 is P-by-Q. Q must be no larger than P, M-P, or M-Q. (If this is not the case, then X must be transposed and/or permuted. This can be done in constant time using the TRANS and SIGNS options. See CUNCSD for details.) The unitary matrices P1, P2, Q1, and Q2 are P-by-P, (M-P)-by- (M-P), Q-by-Q, and (M-Q)-by-(M-Q), respectively. They are represented implicitly by Householder vectors. B11, B12, B21, and B22 are Q-by-Q bidiagonal matrices represented implicitly by angles THETA, PHI.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | trans | |||
| character, | intent(in) | :: | signs | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | p | |||
| integer(kind=ilp), | intent(in) | :: | q | |||
| complex(kind=sp), | intent(inout) | :: | x11(ldx11,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldx11 | |||
| complex(kind=sp), | intent(inout) | :: | x12(ldx12,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldx12 | |||
| complex(kind=sp), | intent(inout) | :: | x21(ldx21,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldx21 | |||
| complex(kind=sp), | intent(inout) | :: | x22(ldx22,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldx22 | |||
| real(kind=sp), | intent(out) | :: | theta(*) | |||
| real(kind=sp), | intent(out) | :: | phi(*) | |||
| complex(kind=sp), | intent(out) | :: | taup1(*) | |||
| complex(kind=sp), | intent(out) | :: | taup2(*) | |||
| complex(kind=sp), | intent(out) | :: | tauq1(*) | |||
| complex(kind=sp), | intent(out) | :: | tauq2(*) | |||
| complex(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
ZUNBDB simultaneously bidiagonalizes the blocks of an M-by-M partitioned unitary matrix X: [ B11 | B12 0 0 ] [ X11 | X12 ] [ P1 | ] [ 0 | 0 -I 0 ] [ Q1 | ]**H X = [-----------] = [---------] [----------------] [---------] . [ X21 | X22 ] [ | P2 ] [ B21 | B22 0 0 ] [ | Q2 ] [ 0 | 0 0 I ] X11 is P-by-Q. Q must be no larger than P, M-P, or M-Q. (If this is not the case, then X must be transposed and/or permuted. This can be done in constant time using the TRANS and SIGNS options. See ZUNCSD for details.) The unitary matrices P1, P2, Q1, and Q2 are P-by-P, (M-P)-by- (M-P), Q-by-Q, and (M-Q)-by-(M-Q), respectively. They are represented implicitly by Householder vectors. B11, B12, B21, and B22 are Q-by-Q bidiagonal matrices represented implicitly by angles THETA, PHI.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | trans | |||
| character, | intent(in) | :: | signs | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | p | |||
| integer(kind=ilp), | intent(in) | :: | q | |||
| complex(kind=dp), | intent(inout) | :: | x11(ldx11,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldx11 | |||
| complex(kind=dp), | intent(inout) | :: | x12(ldx12,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldx12 | |||
| complex(kind=dp), | intent(inout) | :: | x21(ldx21,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldx21 | |||
| complex(kind=dp), | intent(inout) | :: | x22(ldx22,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldx22 | |||
| real(kind=dp), | intent(out) | :: | theta(*) | |||
| real(kind=dp), | intent(out) | :: | phi(*) | |||
| complex(kind=dp), | intent(out) | :: | taup1(*) | |||
| complex(kind=dp), | intent(out) | :: | taup2(*) | |||
| complex(kind=dp), | intent(out) | :: | tauq1(*) | |||
| complex(kind=dp), | intent(out) | :: | tauq2(*) | |||
| complex(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
UNBDB1 simultaneously bidiagonalizes the blocks of a tall and skinny matrix X with orthonomal columns: [ B11 ] [ X11 ] [ P1 | ] [ 0 ] [-----] = [---------] [-----] Q1**T . [ X21 ] [ | P2 ] [ B21 ] [ 0 ] X11 is P-by-Q, and X21 is (M-P)-by-Q. Q must be no larger than P, M-P, or M-Q. Routines CUNBDB2, CUNBDB3, and CUNBDB4 handle cases in which Q is not the minimum dimension. The unitary matrices P1, P2, and Q1 are P-by-P, (M-P)-by-(M-P), and (M-Q)-by-(M-Q), respectively. They are represented implicitly by Householder vectors. B11 and B12 are Q-by-Q bidiagonal matrices represented implicitly by angles THETA, PHI.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | p | |||
| integer(kind=ilp), | intent(in) | :: | q | |||
| complex(kind=sp), | intent(inout) | :: | x11(ldx11,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldx11 | |||
| complex(kind=sp), | intent(inout) | :: | x21(ldx21,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldx21 | |||
| real(kind=sp), | intent(out) | :: | theta(*) | |||
| real(kind=sp), | intent(out) | :: | phi(*) | |||
| complex(kind=sp), | intent(out) | :: | taup1(*) | |||
| complex(kind=sp), | intent(out) | :: | taup2(*) | |||
| complex(kind=sp), | intent(out) | :: | tauq1(*) | |||
| complex(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | p | |||
| integer(kind=ilp), | intent(in) | :: | q | |||
| complex(kind=dp), | intent(inout) | :: | x11(ldx11,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldx11 | |||
| complex(kind=dp), | intent(inout) | :: | x21(ldx21,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldx21 | |||
| real(kind=dp), | intent(out) | :: | theta(*) | |||
| real(kind=dp), | intent(out) | :: | phi(*) | |||
| complex(kind=dp), | intent(out) | :: | taup1(*) | |||
| complex(kind=dp), | intent(out) | :: | taup2(*) | |||
| complex(kind=dp), | intent(out) | :: | tauq1(*) | |||
| complex(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
CUNBDB1 simultaneously bidiagonalizes the blocks of a tall and skinny matrix X with orthonomal columns: [ B11 ] [ X11 ] [ P1 | ] [ 0 ] [-----] = [---------] [-----] Q1**T . [ X21 ] [ | P2 ] [ B21 ] [ 0 ] X11 is P-by-Q, and X21 is (M-P)-by-Q. Q must be no larger than P, M-P, or M-Q. Routines CUNBDB2, CUNBDB3, and CUNBDB4 handle cases in which Q is not the minimum dimension. The unitary matrices P1, P2, and Q1 are P-by-P, (M-P)-by-(M-P), and (M-Q)-by-(M-Q), respectively. They are represented implicitly by Householder vectors. B11 and B12 are Q-by-Q bidiagonal matrices represented implicitly by angles THETA, PHI.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | p | |||
| integer(kind=ilp), | intent(in) | :: | q | |||
| complex(kind=sp), | intent(inout) | :: | x11(ldx11,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldx11 | |||
| complex(kind=sp), | intent(inout) | :: | x21(ldx21,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldx21 | |||
| real(kind=sp), | intent(out) | :: | theta(*) | |||
| real(kind=sp), | intent(out) | :: | phi(*) | |||
| complex(kind=sp), | intent(out) | :: | taup1(*) | |||
| complex(kind=sp), | intent(out) | :: | taup2(*) | |||
| complex(kind=sp), | intent(out) | :: | tauq1(*) | |||
| complex(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
ZUNBDB1 simultaneously bidiagonalizes the blocks of a tall and skinny matrix X with orthonomal columns: [ B11 ] [ X11 ] [ P1 | ] [ 0 ] [-----] = [---------] [-----] Q1**T . [ X21 ] [ | P2 ] [ B21 ] [ 0 ] X11 is P-by-Q, and X21 is (M-P)-by-Q. Q must be no larger than P, M-P, or M-Q. Routines ZUNBDB2, ZUNBDB3, and ZUNBDB4 handle cases in which Q is not the minimum dimension. The unitary matrices P1, P2, and Q1 are P-by-P, (M-P)-by-(M-P), and (M-Q)-by-(M-Q), respectively. They are represented implicitly by Householder vectors. B11 and B12 are Q-by-Q bidiagonal matrices represented implicitly by angles THETA, PHI.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | p | |||
| integer(kind=ilp), | intent(in) | :: | q | |||
| complex(kind=dp), | intent(inout) | :: | x11(ldx11,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldx11 | |||
| complex(kind=dp), | intent(inout) | :: | x21(ldx21,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldx21 | |||
| real(kind=dp), | intent(out) | :: | theta(*) | |||
| real(kind=dp), | intent(out) | :: | phi(*) | |||
| complex(kind=dp), | intent(out) | :: | taup1(*) | |||
| complex(kind=dp), | intent(out) | :: | taup2(*) | |||
| complex(kind=dp), | intent(out) | :: | tauq1(*) | |||
| complex(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
UNBDB2 simultaneously bidiagonalizes the blocks of a tall and skinny matrix X with orthonomal columns: [ B11 ] [ X11 ] [ P1 | ] [ 0 ] [-----] = [---------] [-----] Q1**T . [ X21 ] [ | P2 ] [ B21 ] [ 0 ] X11 is P-by-Q, and X21 is (M-P)-by-Q. P must be no larger than M-P, Q, or M-Q. Routines CUNBDB1, CUNBDB3, and CUNBDB4 handle cases in which P is not the minimum dimension. The unitary matrices P1, P2, and Q1 are P-by-P, (M-P)-by-(M-P), and (M-Q)-by-(M-Q), respectively. They are represented implicitly by Householder vectors. B11 and B12 are P-by-P bidiagonal matrices represented implicitly by angles THETA, PHI.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | p | |||
| integer(kind=ilp), | intent(in) | :: | q | |||
| complex(kind=sp), | intent(inout) | :: | x11(ldx11,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldx11 | |||
| complex(kind=sp), | intent(inout) | :: | x21(ldx21,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldx21 | |||
| real(kind=sp), | intent(out) | :: | theta(*) | |||
| real(kind=sp), | intent(out) | :: | phi(*) | |||
| complex(kind=sp), | intent(out) | :: | taup1(*) | |||
| complex(kind=sp), | intent(out) | :: | taup2(*) | |||
| complex(kind=sp), | intent(out) | :: | tauq1(*) | |||
| complex(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | p | |||
| integer(kind=ilp), | intent(in) | :: | q | |||
| complex(kind=dp), | intent(inout) | :: | x11(ldx11,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldx11 | |||
| complex(kind=dp), | intent(inout) | :: | x21(ldx21,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldx21 | |||
| real(kind=dp), | intent(out) | :: | theta(*) | |||
| real(kind=dp), | intent(out) | :: | phi(*) | |||
| complex(kind=dp), | intent(out) | :: | taup1(*) | |||
| complex(kind=dp), | intent(out) | :: | taup2(*) | |||
| complex(kind=dp), | intent(out) | :: | tauq1(*) | |||
| complex(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
CUNBDB2 simultaneously bidiagonalizes the blocks of a tall and skinny matrix X with orthonomal columns: [ B11 ] [ X11 ] [ P1 | ] [ 0 ] [-----] = [---------] [-----] Q1**T . [ X21 ] [ | P2 ] [ B21 ] [ 0 ] X11 is P-by-Q, and X21 is (M-P)-by-Q. P must be no larger than M-P, Q, or M-Q. Routines CUNBDB1, CUNBDB3, and CUNBDB4 handle cases in which P is not the minimum dimension. The unitary matrices P1, P2, and Q1 are P-by-P, (M-P)-by-(M-P), and (M-Q)-by-(M-Q), respectively. They are represented implicitly by Householder vectors. B11 and B12 are P-by-P bidiagonal matrices represented implicitly by angles THETA, PHI.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | p | |||
| integer(kind=ilp), | intent(in) | :: | q | |||
| complex(kind=sp), | intent(inout) | :: | x11(ldx11,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldx11 | |||
| complex(kind=sp), | intent(inout) | :: | x21(ldx21,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldx21 | |||
| real(kind=sp), | intent(out) | :: | theta(*) | |||
| real(kind=sp), | intent(out) | :: | phi(*) | |||
| complex(kind=sp), | intent(out) | :: | taup1(*) | |||
| complex(kind=sp), | intent(out) | :: | taup2(*) | |||
| complex(kind=sp), | intent(out) | :: | tauq1(*) | |||
| complex(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
ZUNBDB2 simultaneously bidiagonalizes the blocks of a tall and skinny matrix X with orthonomal columns: [ B11 ] [ X11 ] [ P1 | ] [ 0 ] [-----] = [---------] [-----] Q1**T . [ X21 ] [ | P2 ] [ B21 ] [ 0 ] X11 is P-by-Q, and X21 is (M-P)-by-Q. P must be no larger than M-P, Q, or M-Q. Routines ZUNBDB1, ZUNBDB3, and ZUNBDB4 handle cases in which P is not the minimum dimension. The unitary matrices P1, P2, and Q1 are P-by-P, (M-P)-by-(M-P), and (M-Q)-by-(M-Q), respectively. They are represented implicitly by Householder vectors. B11 and B12 are P-by-P bidiagonal matrices represented implicitly by angles THETA, PHI.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | p | |||
| integer(kind=ilp), | intent(in) | :: | q | |||
| complex(kind=dp), | intent(inout) | :: | x11(ldx11,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldx11 | |||
| complex(kind=dp), | intent(inout) | :: | x21(ldx21,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldx21 | |||
| real(kind=dp), | intent(out) | :: | theta(*) | |||
| real(kind=dp), | intent(out) | :: | phi(*) | |||
| complex(kind=dp), | intent(out) | :: | taup1(*) | |||
| complex(kind=dp), | intent(out) | :: | taup2(*) | |||
| complex(kind=dp), | intent(out) | :: | tauq1(*) | |||
| complex(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
UNBDB3 simultaneously bidiagonalizes the blocks of a tall and skinny matrix X with orthonomal columns: [ B11 ] [ X11 ] [ P1 | ] [ 0 ] [-----] = [---------] [-----] Q1**T . [ X21 ] [ | P2 ] [ B21 ] [ 0 ] X11 is P-by-Q, and X21 is (M-P)-by-Q. M-P must be no larger than P, Q, or M-Q. Routines CUNBDB1, CUNBDB2, and CUNBDB4 handle cases in which M-P is not the minimum dimension. The unitary matrices P1, P2, and Q1 are P-by-P, (M-P)-by-(M-P), and (M-Q)-by-(M-Q), respectively. They are represented implicitly by Householder vectors. B11 and B12 are (M-P)-by-(M-P) bidiagonal matrices represented implicitly by angles THETA, PHI.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | p | |||
| integer(kind=ilp), | intent(in) | :: | q | |||
| complex(kind=sp), | intent(inout) | :: | x11(ldx11,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldx11 | |||
| complex(kind=sp), | intent(inout) | :: | x21(ldx21,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldx21 | |||
| real(kind=sp), | intent(out) | :: | theta(*) | |||
| real(kind=sp), | intent(out) | :: | phi(*) | |||
| complex(kind=sp), | intent(out) | :: | taup1(*) | |||
| complex(kind=sp), | intent(out) | :: | taup2(*) | |||
| complex(kind=sp), | intent(out) | :: | tauq1(*) | |||
| complex(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | p | |||
| integer(kind=ilp), | intent(in) | :: | q | |||
| complex(kind=dp), | intent(inout) | :: | x11(ldx11,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldx11 | |||
| complex(kind=dp), | intent(inout) | :: | x21(ldx21,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldx21 | |||
| real(kind=dp), | intent(out) | :: | theta(*) | |||
| real(kind=dp), | intent(out) | :: | phi(*) | |||
| complex(kind=dp), | intent(out) | :: | taup1(*) | |||
| complex(kind=dp), | intent(out) | :: | taup2(*) | |||
| complex(kind=dp), | intent(out) | :: | tauq1(*) | |||
| complex(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
CUNBDB3 simultaneously bidiagonalizes the blocks of a tall and skinny matrix X with orthonomal columns: [ B11 ] [ X11 ] [ P1 | ] [ 0 ] [-----] = [---------] [-----] Q1**T . [ X21 ] [ | P2 ] [ B21 ] [ 0 ] X11 is P-by-Q, and X21 is (M-P)-by-Q. M-P must be no larger than P, Q, or M-Q. Routines CUNBDB1, CUNBDB2, and CUNBDB4 handle cases in which M-P is not the minimum dimension. The unitary matrices P1, P2, and Q1 are P-by-P, (M-P)-by-(M-P), and (M-Q)-by-(M-Q), respectively. They are represented implicitly by Householder vectors. B11 and B12 are (M-P)-by-(M-P) bidiagonal matrices represented implicitly by angles THETA, PHI.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | p | |||
| integer(kind=ilp), | intent(in) | :: | q | |||
| complex(kind=sp), | intent(inout) | :: | x11(ldx11,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldx11 | |||
| complex(kind=sp), | intent(inout) | :: | x21(ldx21,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldx21 | |||
| real(kind=sp), | intent(out) | :: | theta(*) | |||
| real(kind=sp), | intent(out) | :: | phi(*) | |||
| complex(kind=sp), | intent(out) | :: | taup1(*) | |||
| complex(kind=sp), | intent(out) | :: | taup2(*) | |||
| complex(kind=sp), | intent(out) | :: | tauq1(*) | |||
| complex(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
ZUNBDB3 simultaneously bidiagonalizes the blocks of a tall and skinny matrix X with orthonomal columns: [ B11 ] [ X11 ] [ P1 | ] [ 0 ] [-----] = [---------] [-----] Q1**T . [ X21 ] [ | P2 ] [ B21 ] [ 0 ] X11 is P-by-Q, and X21 is (M-P)-by-Q. M-P must be no larger than P, Q, or M-Q. Routines ZUNBDB1, ZUNBDB2, and ZUNBDB4 handle cases in which M-P is not the minimum dimension. The unitary matrices P1, P2, and Q1 are P-by-P, (M-P)-by-(M-P), and (M-Q)-by-(M-Q), respectively. They are represented implicitly by Householder vectors. B11 and B12 are (M-P)-by-(M-P) bidiagonal matrices represented implicitly by angles THETA, PHI.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | p | |||
| integer(kind=ilp), | intent(in) | :: | q | |||
| complex(kind=dp), | intent(inout) | :: | x11(ldx11,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldx11 | |||
| complex(kind=dp), | intent(inout) | :: | x21(ldx21,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldx21 | |||
| real(kind=dp), | intent(out) | :: | theta(*) | |||
| real(kind=dp), | intent(out) | :: | phi(*) | |||
| complex(kind=dp), | intent(out) | :: | taup1(*) | |||
| complex(kind=dp), | intent(out) | :: | taup2(*) | |||
| complex(kind=dp), | intent(out) | :: | tauq1(*) | |||
| complex(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
UNBDB4 simultaneously bidiagonalizes the blocks of a tall and skinny matrix X with orthonomal columns: [ B11 ] [ X11 ] [ P1 | ] [ 0 ] [-----] = [---------] [-----] Q1**T . [ X21 ] [ | P2 ] [ B21 ] [ 0 ] X11 is P-by-Q, and X21 is (M-P)-by-Q. M-Q must be no larger than P, M-P, or Q. Routines CUNBDB1, CUNBDB2, and CUNBDB3 handle cases in which M-Q is not the minimum dimension. The unitary matrices P1, P2, and Q1 are P-by-P, (M-P)-by-(M-P), and (M-Q)-by-(M-Q), respectively. They are represented implicitly by Householder vectors. B11 and B12 are (M-Q)-by-(M-Q) bidiagonal matrices represented implicitly by angles THETA, PHI.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | p | |||
| integer(kind=ilp), | intent(in) | :: | q | |||
| complex(kind=sp), | intent(inout) | :: | x11(ldx11,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldx11 | |||
| complex(kind=sp), | intent(inout) | :: | x21(ldx21,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldx21 | |||
| real(kind=sp), | intent(out) | :: | theta(*) | |||
| real(kind=sp), | intent(out) | :: | phi(*) | |||
| complex(kind=sp), | intent(out) | :: | taup1(*) | |||
| complex(kind=sp), | intent(out) | :: | taup2(*) | |||
| complex(kind=sp), | intent(out) | :: | tauq1(*) | |||
| complex(kind=sp), | intent(out) | :: | phantom(*) | |||
| complex(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | p | |||
| integer(kind=ilp), | intent(in) | :: | q | |||
| complex(kind=dp), | intent(inout) | :: | x11(ldx11,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldx11 | |||
| complex(kind=dp), | intent(inout) | :: | x21(ldx21,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldx21 | |||
| real(kind=dp), | intent(out) | :: | theta(*) | |||
| real(kind=dp), | intent(out) | :: | phi(*) | |||
| complex(kind=dp), | intent(out) | :: | taup1(*) | |||
| complex(kind=dp), | intent(out) | :: | taup2(*) | |||
| complex(kind=dp), | intent(out) | :: | tauq1(*) | |||
| complex(kind=dp), | intent(out) | :: | phantom(*) | |||
| complex(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
CUNBDB4 simultaneously bidiagonalizes the blocks of a tall and skinny matrix X with orthonomal columns: [ B11 ] [ X11 ] [ P1 | ] [ 0 ] [-----] = [---------] [-----] Q1**T . [ X21 ] [ | P2 ] [ B21 ] [ 0 ] X11 is P-by-Q, and X21 is (M-P)-by-Q. M-Q must be no larger than P, M-P, or Q. Routines CUNBDB1, CUNBDB2, and CUNBDB3 handle cases in which M-Q is not the minimum dimension. The unitary matrices P1, P2, and Q1 are P-by-P, (M-P)-by-(M-P), and (M-Q)-by-(M-Q), respectively. They are represented implicitly by Householder vectors. B11 and B12 are (M-Q)-by-(M-Q) bidiagonal matrices represented implicitly by angles THETA, PHI.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | p | |||
| integer(kind=ilp), | intent(in) | :: | q | |||
| complex(kind=sp), | intent(inout) | :: | x11(ldx11,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldx11 | |||
| complex(kind=sp), | intent(inout) | :: | x21(ldx21,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldx21 | |||
| real(kind=sp), | intent(out) | :: | theta(*) | |||
| real(kind=sp), | intent(out) | :: | phi(*) | |||
| complex(kind=sp), | intent(out) | :: | taup1(*) | |||
| complex(kind=sp), | intent(out) | :: | taup2(*) | |||
| complex(kind=sp), | intent(out) | :: | tauq1(*) | |||
| complex(kind=sp), | intent(out) | :: | phantom(*) | |||
| complex(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
ZUNBDB4 simultaneously bidiagonalizes the blocks of a tall and skinny matrix X with orthonomal columns: [ B11 ] [ X11 ] [ P1 | ] [ 0 ] [-----] = [---------] [-----] Q1**T . [ X21 ] [ | P2 ] [ B21 ] [ 0 ] X11 is P-by-Q, and X21 is (M-P)-by-Q. M-Q must be no larger than P, M-P, or Q. Routines ZUNBDB1, ZUNBDB2, and ZUNBDB3 handle cases in which M-Q is not the minimum dimension. The unitary matrices P1, P2, and Q1 are P-by-P, (M-P)-by-(M-P), and (M-Q)-by-(M-Q), respectively. They are represented implicitly by Householder vectors. B11 and B12 are (M-Q)-by-(M-Q) bidiagonal matrices represented implicitly by angles THETA, PHI.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | p | |||
| integer(kind=ilp), | intent(in) | :: | q | |||
| complex(kind=dp), | intent(inout) | :: | x11(ldx11,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldx11 | |||
| complex(kind=dp), | intent(inout) | :: | x21(ldx21,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldx21 | |||
| real(kind=dp), | intent(out) | :: | theta(*) | |||
| real(kind=dp), | intent(out) | :: | phi(*) | |||
| complex(kind=dp), | intent(out) | :: | taup1(*) | |||
| complex(kind=dp), | intent(out) | :: | taup2(*) | |||
| complex(kind=dp), | intent(out) | :: | tauq1(*) | |||
| complex(kind=dp), | intent(out) | :: | phantom(*) | |||
| complex(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
UNBDB5 orthogonalizes the column vector X = [ X1 ] [ X2 ] with respect to the columns of Q = [ Q1 ] . [ Q2 ] The columns of Q must be orthonormal. If the projection is zero according to Kahan's "twice is enough" criterion, then some other vector from the orthogonal complement is returned. This vector is chosen in an arbitrary but deterministic way.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m1 | |||
| integer(kind=ilp), | intent(in) | :: | m2 | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=sp), | intent(inout) | :: | x1(*) | |||
| integer(kind=ilp), | intent(in) | :: | incx1 | |||
| complex(kind=sp), | intent(inout) | :: | x2(*) | |||
| integer(kind=ilp), | intent(in) | :: | incx2 | |||
| complex(kind=sp), | intent(in) | :: | q1(ldq1,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldq1 | |||
| complex(kind=sp), | intent(in) | :: | q2(ldq2,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldq2 | |||
| complex(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m1 | |||
| integer(kind=ilp), | intent(in) | :: | m2 | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=dp), | intent(inout) | :: | x1(*) | |||
| integer(kind=ilp), | intent(in) | :: | incx1 | |||
| complex(kind=dp), | intent(inout) | :: | x2(*) | |||
| integer(kind=ilp), | intent(in) | :: | incx2 | |||
| complex(kind=dp), | intent(in) | :: | q1(ldq1,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldq1 | |||
| complex(kind=dp), | intent(in) | :: | q2(ldq2,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldq2 | |||
| complex(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
CUNBDB5 orthogonalizes the column vector X = [ X1 ] [ X2 ] with respect to the columns of Q = [ Q1 ] . [ Q2 ] The columns of Q must be orthonormal. If the projection is zero according to Kahan's "twice is enough" criterion, then some other vector from the orthogonal complement is returned. This vector is chosen in an arbitrary but deterministic way.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m1 | |||
| integer(kind=ilp), | intent(in) | :: | m2 | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=sp), | intent(inout) | :: | x1(*) | |||
| integer(kind=ilp), | intent(in) | :: | incx1 | |||
| complex(kind=sp), | intent(inout) | :: | x2(*) | |||
| integer(kind=ilp), | intent(in) | :: | incx2 | |||
| complex(kind=sp), | intent(in) | :: | q1(ldq1,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldq1 | |||
| complex(kind=sp), | intent(in) | :: | q2(ldq2,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldq2 | |||
| complex(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
ZUNBDB5 orthogonalizes the column vector X = [ X1 ] [ X2 ] with respect to the columns of Q = [ Q1 ] . [ Q2 ] The columns of Q must be orthonormal. If the projection is zero according to Kahan's "twice is enough" criterion, then some other vector from the orthogonal complement is returned. This vector is chosen in an arbitrary but deterministic way.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m1 | |||
| integer(kind=ilp), | intent(in) | :: | m2 | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=dp), | intent(inout) | :: | x1(*) | |||
| integer(kind=ilp), | intent(in) | :: | incx1 | |||
| complex(kind=dp), | intent(inout) | :: | x2(*) | |||
| integer(kind=ilp), | intent(in) | :: | incx2 | |||
| complex(kind=dp), | intent(in) | :: | q1(ldq1,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldq1 | |||
| complex(kind=dp), | intent(in) | :: | q2(ldq2,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldq2 | |||
| complex(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
UNBDB6 orthogonalizes the column vector X = [ X1 ] [ X2 ] with respect to the columns of Q = [ Q1 ] . [ Q2 ] The columns of Q must be orthonormal. If the projection is zero according to Kahan's "twice is enough" criterion, then the zero vector is returned.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m1 | |||
| integer(kind=ilp), | intent(in) | :: | m2 | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=sp), | intent(inout) | :: | x1(*) | |||
| integer(kind=ilp), | intent(in) | :: | incx1 | |||
| complex(kind=sp), | intent(inout) | :: | x2(*) | |||
| integer(kind=ilp), | intent(in) | :: | incx2 | |||
| complex(kind=sp), | intent(in) | :: | q1(ldq1,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldq1 | |||
| complex(kind=sp), | intent(in) | :: | q2(ldq2,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldq2 | |||
| complex(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m1 | |||
| integer(kind=ilp), | intent(in) | :: | m2 | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=dp), | intent(inout) | :: | x1(*) | |||
| integer(kind=ilp), | intent(in) | :: | incx1 | |||
| complex(kind=dp), | intent(inout) | :: | x2(*) | |||
| integer(kind=ilp), | intent(in) | :: | incx2 | |||
| complex(kind=dp), | intent(in) | :: | q1(ldq1,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldq1 | |||
| complex(kind=dp), | intent(in) | :: | q2(ldq2,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldq2 | |||
| complex(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
CUNBDB6 orthogonalizes the column vector X = [ X1 ] [ X2 ] with respect to the columns of Q = [ Q1 ] . [ Q2 ] The columns of Q must be orthonormal. If the projection is zero according to Kahan's "twice is enough" criterion, then the zero vector is returned.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m1 | |||
| integer(kind=ilp), | intent(in) | :: | m2 | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=sp), | intent(inout) | :: | x1(*) | |||
| integer(kind=ilp), | intent(in) | :: | incx1 | |||
| complex(kind=sp), | intent(inout) | :: | x2(*) | |||
| integer(kind=ilp), | intent(in) | :: | incx2 | |||
| complex(kind=sp), | intent(in) | :: | q1(ldq1,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldq1 | |||
| complex(kind=sp), | intent(in) | :: | q2(ldq2,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldq2 | |||
| complex(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
ZUNBDB6 orthogonalizes the column vector X = [ X1 ] [ X2 ] with respect to the columns of Q = [ Q1 ] . [ Q2 ] The columns of Q must be orthonormal. If the projection is zero according to Kahan's "twice is enough" criterion, then the zero vector is returned.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m1 | |||
| integer(kind=ilp), | intent(in) | :: | m2 | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=dp), | intent(inout) | :: | x1(*) | |||
| integer(kind=ilp), | intent(in) | :: | incx1 | |||
| complex(kind=dp), | intent(inout) | :: | x2(*) | |||
| integer(kind=ilp), | intent(in) | :: | incx2 | |||
| complex(kind=dp), | intent(in) | :: | q1(ldq1,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldq1 | |||
| complex(kind=dp), | intent(in) | :: | q2(ldq2,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldq2 | |||
| complex(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
UNCSD computes the CS decomposition of an M-by-M partitioned unitary matrix X: [ I 0 0 | 0 0 0 ] [ 0 C 0 | 0 -S 0 ] [ X11 | X12 ] [ U1 | ] [ 0 0 0 | 0 0 -I ] [ V1 | ]**H X = [-----------] = [---------] [---------------------] [---------] . [ X21 | X22 ] [ | U2 ] [ 0 0 0 | I 0 0 ] [ | V2 ] [ 0 S 0 | 0 C 0 ] [ 0 0 I | 0 0 0 ] X11 is P-by-Q. The unitary matrices U1, U2, V1, and V2 are P-by-P, (M-P)-by-(M-P), Q-by-Q, and (M-Q)-by-(M-Q), respectively. C and S are R-by-R nonnegative diagonal matrices satisfying C^2 + S^2 = I, in which R = MIN(P,M-P,Q,M-Q).
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | jobu1 | |||
| character, | intent(in) | :: | jobu2 | |||
| character, | intent(in) | :: | jobv1t | |||
| character, | intent(in) | :: | jobv2t | |||
| character, | intent(in) | :: | trans | |||
| character, | intent(in) | :: | signs | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | p | |||
| integer(kind=ilp), | intent(in) | :: | q | |||
| complex(kind=sp), | intent(inout) | :: | x11(ldx11,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldx11 | |||
| complex(kind=sp), | intent(inout) | :: | x12(ldx12,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldx12 | |||
| complex(kind=sp), | intent(inout) | :: | x21(ldx21,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldx21 | |||
| complex(kind=sp), | intent(inout) | :: | x22(ldx22,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldx22 | |||
| real(kind=sp), | intent(out) | :: | theta(*) | |||
| complex(kind=sp), | intent(out) | :: | u1(ldu1,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldu1 | |||
| complex(kind=sp), | intent(out) | :: | u2(ldu2,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldu2 | |||
| complex(kind=sp), | intent(out) | :: | v1t(ldv1t,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldv1t | |||
| complex(kind=sp), | intent(out) | :: | v2t(ldv2t,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldv2t | |||
| complex(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| real(kind=sp), | intent(out) | :: | rwork(*) | |||
| integer(kind=ilp), | intent(in) | :: | lrwork | |||
| integer(kind=ilp), | intent(out) | :: | iwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | jobu1 | |||
| character, | intent(in) | :: | jobu2 | |||
| character, | intent(in) | :: | jobv1t | |||
| character, | intent(in) | :: | jobv2t | |||
| character, | intent(in) | :: | trans | |||
| character, | intent(in) | :: | signs | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | p | |||
| integer(kind=ilp), | intent(in) | :: | q | |||
| complex(kind=dp), | intent(inout) | :: | x11(ldx11,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldx11 | |||
| complex(kind=dp), | intent(inout) | :: | x12(ldx12,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldx12 | |||
| complex(kind=dp), | intent(inout) | :: | x21(ldx21,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldx21 | |||
| complex(kind=dp), | intent(inout) | :: | x22(ldx22,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldx22 | |||
| real(kind=dp), | intent(out) | :: | theta(*) | |||
| complex(kind=dp), | intent(out) | :: | u1(ldu1,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldu1 | |||
| complex(kind=dp), | intent(out) | :: | u2(ldu2,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldu2 | |||
| complex(kind=dp), | intent(out) | :: | v1t(ldv1t,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldv1t | |||
| complex(kind=dp), | intent(out) | :: | v2t(ldv2t,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldv2t | |||
| complex(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| real(kind=dp), | intent(out) | :: | rwork(*) | |||
| integer(kind=ilp), | intent(in) | :: | lrwork | |||
| integer(kind=ilp), | intent(out) | :: | iwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
CUNCSD computes the CS decomposition of an M-by-M partitioned unitary matrix X: [ I 0 0 | 0 0 0 ] [ 0 C 0 | 0 -S 0 ] [ X11 | X12 ] [ U1 | ] [ 0 0 0 | 0 0 -I ] [ V1 | ]**H X = [-----------] = [---------] [---------------------] [---------] . [ X21 | X22 ] [ | U2 ] [ 0 0 0 | I 0 0 ] [ | V2 ] [ 0 S 0 | 0 C 0 ] [ 0 0 I | 0 0 0 ] X11 is P-by-Q. The unitary matrices U1, U2, V1, and V2 are P-by-P, (M-P)-by-(M-P), Q-by-Q, and (M-Q)-by-(M-Q), respectively. C and S are R-by-R nonnegative diagonal matrices satisfying C^2 + S^2 = I, in which R = MIN(P,M-P,Q,M-Q).
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | jobu1 | |||
| character, | intent(in) | :: | jobu2 | |||
| character, | intent(in) | :: | jobv1t | |||
| character, | intent(in) | :: | jobv2t | |||
| character, | intent(in) | :: | trans | |||
| character, | intent(in) | :: | signs | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | p | |||
| integer(kind=ilp), | intent(in) | :: | q | |||
| complex(kind=sp), | intent(inout) | :: | x11(ldx11,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldx11 | |||
| complex(kind=sp), | intent(inout) | :: | x12(ldx12,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldx12 | |||
| complex(kind=sp), | intent(inout) | :: | x21(ldx21,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldx21 | |||
| complex(kind=sp), | intent(inout) | :: | x22(ldx22,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldx22 | |||
| real(kind=sp), | intent(out) | :: | theta(*) | |||
| complex(kind=sp), | intent(out) | :: | u1(ldu1,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldu1 | |||
| complex(kind=sp), | intent(out) | :: | u2(ldu2,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldu2 | |||
| complex(kind=sp), | intent(out) | :: | v1t(ldv1t,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldv1t | |||
| complex(kind=sp), | intent(out) | :: | v2t(ldv2t,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldv2t | |||
| complex(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| real(kind=sp), | intent(out) | :: | rwork(*) | |||
| integer(kind=ilp), | intent(in) | :: | lrwork | |||
| integer(kind=ilp), | intent(out) | :: | iwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
ZUNCSD computes the CS decomposition of an M-by-M partitioned unitary matrix X: [ I 0 0 | 0 0 0 ] [ 0 C 0 | 0 -S 0 ] [ X11 | X12 ] [ U1 | ] [ 0 0 0 | 0 0 -I ] [ V1 | ]**H X = [-----------] = [---------] [---------------------] [---------] . [ X21 | X22 ] [ | U2 ] [ 0 0 0 | I 0 0 ] [ | V2 ] [ 0 S 0 | 0 C 0 ] [ 0 0 I | 0 0 0 ] X11 is P-by-Q. The unitary matrices U1, U2, V1, and V2 are P-by-P, (M-P)-by-(M-P), Q-by-Q, and (M-Q)-by-(M-Q), respectively. C and S are R-by-R nonnegative diagonal matrices satisfying C^2 + S^2 = I, in which R = MIN(P,M-P,Q,M-Q).
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | jobu1 | |||
| character, | intent(in) | :: | jobu2 | |||
| character, | intent(in) | :: | jobv1t | |||
| character, | intent(in) | :: | jobv2t | |||
| character, | intent(in) | :: | trans | |||
| character, | intent(in) | :: | signs | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | p | |||
| integer(kind=ilp), | intent(in) | :: | q | |||
| complex(kind=dp), | intent(inout) | :: | x11(ldx11,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldx11 | |||
| complex(kind=dp), | intent(inout) | :: | x12(ldx12,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldx12 | |||
| complex(kind=dp), | intent(inout) | :: | x21(ldx21,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldx21 | |||
| complex(kind=dp), | intent(inout) | :: | x22(ldx22,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldx22 | |||
| real(kind=dp), | intent(out) | :: | theta(*) | |||
| complex(kind=dp), | intent(out) | :: | u1(ldu1,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldu1 | |||
| complex(kind=dp), | intent(out) | :: | u2(ldu2,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldu2 | |||
| complex(kind=dp), | intent(out) | :: | v1t(ldv1t,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldv1t | |||
| complex(kind=dp), | intent(out) | :: | v2t(ldv2t,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldv2t | |||
| complex(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| real(kind=dp), | intent(out) | :: | rwork(*) | |||
| integer(kind=ilp), | intent(in) | :: | lrwork | |||
| integer(kind=ilp), | intent(out) | :: | iwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
UNCSD2BY1 computes the CS decomposition of an M-by-Q matrix X with orthonormal columns that has been partitioned into a 2-by-1 block structure: [ I1 0 0 ] [ 0 C 0 ] [ X11 ] [ U1 | ] [ 0 0 0 ] X = [-----] = [---------] [----------] V1**T . [ X21 ] [ | U2 ] [ 0 0 0 ] [ 0 S 0 ] [ 0 0 I2] X11 is P-by-Q. The unitary matrices U1, U2, and V1 are P-by-P, (M-P)-by-(M-P), and Q-by-Q, respectively. C and S are R-by-R nonnegative diagonal matrices satisfying C^2 + S^2 = I, in which R = MIN(P,M-P,Q,M-Q). I1 is a K1-by-K1 identity matrix and I2 is a K2-by-K2 identity matrix, where K1 = MAX(Q+P-M,0), K2 = MAX(Q-P,0).
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | jobu1 | |||
| character, | intent(in) | :: | jobu2 | |||
| character, | intent(in) | :: | jobv1t | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | p | |||
| integer(kind=ilp), | intent(in) | :: | q | |||
| complex(kind=sp), | intent(inout) | :: | x11(ldx11,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldx11 | |||
| complex(kind=sp), | intent(inout) | :: | x21(ldx21,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldx21 | |||
| real(kind=sp), | intent(out) | :: | theta(*) | |||
| complex(kind=sp), | intent(out) | :: | u1(ldu1,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldu1 | |||
| complex(kind=sp), | intent(out) | :: | u2(ldu2,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldu2 | |||
| complex(kind=sp), | intent(out) | :: | v1t(ldv1t,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldv1t | |||
| complex(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| real(kind=sp), | intent(out) | :: | rwork(*) | |||
| integer(kind=ilp), | intent(in) | :: | lrwork | |||
| integer(kind=ilp), | intent(out) | :: | iwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | jobu1 | |||
| character, | intent(in) | :: | jobu2 | |||
| character, | intent(in) | :: | jobv1t | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | p | |||
| integer(kind=ilp), | intent(in) | :: | q | |||
| complex(kind=dp), | intent(inout) | :: | x11(ldx11,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldx11 | |||
| complex(kind=dp), | intent(inout) | :: | x21(ldx21,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldx21 | |||
| real(kind=dp), | intent(out) | :: | theta(*) | |||
| complex(kind=dp), | intent(out) | :: | u1(ldu1,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldu1 | |||
| complex(kind=dp), | intent(out) | :: | u2(ldu2,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldu2 | |||
| complex(kind=dp), | intent(out) | :: | v1t(ldv1t,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldv1t | |||
| complex(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| real(kind=dp), | intent(out) | :: | rwork(*) | |||
| integer(kind=ilp), | intent(in) | :: | lrwork | |||
| integer(kind=ilp), | intent(out) | :: | iwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
CUNCSD2BY1 computes the CS decomposition of an M-by-Q matrix X with orthonormal columns that has been partitioned into a 2-by-1 block structure: [ I1 0 0 ] [ 0 C 0 ] [ X11 ] [ U1 | ] [ 0 0 0 ] X = [-----] = [---------] [----------] V1**T . [ X21 ] [ | U2 ] [ 0 0 0 ] [ 0 S 0 ] [ 0 0 I2] X11 is P-by-Q. The unitary matrices U1, U2, and V1 are P-by-P, (M-P)-by-(M-P), and Q-by-Q, respectively. C and S are R-by-R nonnegative diagonal matrices satisfying C^2 + S^2 = I, in which R = MIN(P,M-P,Q,M-Q). I1 is a K1-by-K1 identity matrix and I2 is a K2-by-K2 identity matrix, where K1 = MAX(Q+P-M,0), K2 = MAX(Q-P,0).
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | jobu1 | |||
| character, | intent(in) | :: | jobu2 | |||
| character, | intent(in) | :: | jobv1t | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | p | |||
| integer(kind=ilp), | intent(in) | :: | q | |||
| complex(kind=sp), | intent(inout) | :: | x11(ldx11,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldx11 | |||
| complex(kind=sp), | intent(inout) | :: | x21(ldx21,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldx21 | |||
| real(kind=sp), | intent(out) | :: | theta(*) | |||
| complex(kind=sp), | intent(out) | :: | u1(ldu1,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldu1 | |||
| complex(kind=sp), | intent(out) | :: | u2(ldu2,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldu2 | |||
| complex(kind=sp), | intent(out) | :: | v1t(ldv1t,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldv1t | |||
| complex(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| real(kind=sp), | intent(out) | :: | rwork(*) | |||
| integer(kind=ilp), | intent(in) | :: | lrwork | |||
| integer(kind=ilp), | intent(out) | :: | iwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
ZUNCSD2BY1 computes the CS decomposition of an M-by-Q matrix X with orthonormal columns that has been partitioned into a 2-by-1 block structure: [ I1 0 0 ] [ 0 C 0 ] [ X11 ] [ U1 | ] [ 0 0 0 ] X = [-----] = [---------] [----------] V1**T . [ X21 ] [ | U2 ] [ 0 0 0 ] [ 0 S 0 ] [ 0 0 I2] X11 is P-by-Q. The unitary matrices U1, U2, and V1 are P-by-P, (M-P)-by-(M-P), and Q-by-Q, respectively. C and S are R-by-R nonnegative diagonal matrices satisfying C^2 + S^2 = I, in which R = MIN(P,M-P,Q,M-Q). I1 is a K1-by-K1 identity matrix and I2 is a K2-by-K2 identity matrix, where K1 = MAX(Q+P-M,0), K2 = MAX(Q-P,0).
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | jobu1 | |||
| character, | intent(in) | :: | jobu2 | |||
| character, | intent(in) | :: | jobv1t | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | p | |||
| integer(kind=ilp), | intent(in) | :: | q | |||
| complex(kind=dp), | intent(inout) | :: | x11(ldx11,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldx11 | |||
| complex(kind=dp), | intent(inout) | :: | x21(ldx21,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldx21 | |||
| real(kind=dp), | intent(out) | :: | theta(*) | |||
| complex(kind=dp), | intent(out) | :: | u1(ldu1,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldu1 | |||
| complex(kind=dp), | intent(out) | :: | u2(ldu2,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldu2 | |||
| complex(kind=dp), | intent(out) | :: | v1t(ldv1t,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldv1t | |||
| complex(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| real(kind=dp), | intent(out) | :: | rwork(*) | |||
| integer(kind=ilp), | intent(in) | :: | lrwork | |||
| integer(kind=ilp), | intent(out) | :: | iwork(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
UNG2L generates an m by n complex matrix Q with orthonormal columns, which is defined as the last n columns of a product of k elementary reflectors of order m Q = H(k) . . . H(2) H(1) as returned by CGEQLF.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | k | |||
| complex(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=sp), | intent(in) | :: | tau(*) | |||
| complex(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | k | |||
| complex(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=dp), | intent(in) | :: | tau(*) | |||
| complex(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
CUNG2L generates an m by n complex matrix Q with orthonormal columns, which is defined as the last n columns of a product of k elementary reflectors of order m Q = H(k) . . . H(2) H(1) as returned by CGEQLF.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | k | |||
| complex(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=sp), | intent(in) | :: | tau(*) | |||
| complex(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
ZUNG2L generates an m by n complex matrix Q with orthonormal columns, which is defined as the last n columns of a product of k elementary reflectors of order m Q = H(k) . . . H(2) H(1) as returned by ZGEQLF.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | k | |||
| complex(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=dp), | intent(in) | :: | tau(*) | |||
| complex(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
UNG2R generates an m by n complex matrix Q with orthonormal columns, which is defined as the first n columns of a product of k elementary reflectors of order m Q = H(1) H(2) . . . H(k) as returned by CGEQRF.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | k | |||
| complex(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=sp), | intent(in) | :: | tau(*) | |||
| complex(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | k | |||
| complex(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=dp), | intent(in) | :: | tau(*) | |||
| complex(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
CUNG2R generates an m by n complex matrix Q with orthonormal columns, which is defined as the first n columns of a product of k elementary reflectors of order m Q = H(1) H(2) . . . H(k) as returned by CGEQRF.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | k | |||
| complex(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=sp), | intent(in) | :: | tau(*) | |||
| complex(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
ZUNG2R generates an m by n complex matrix Q with orthonormal columns, which is defined as the first n columns of a product of k elementary reflectors of order m Q = H(1) H(2) . . . H(k) as returned by ZGEQRF.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | k | |||
| complex(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=dp), | intent(in) | :: | tau(*) | |||
| complex(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
UNGBR generates one of the complex unitary matrices Q or PH determined by CGEBRD when reducing a complex matrix A to bidiagonal form: A = Q * B * PH. Q and PH are defined as products of elementary reflectors H(i) or G(i) respectively. If VECT = 'Q', A is assumed to have been an M-by-K matrix, and Q is of order M: if m >= k, Q = H(1) H(2) . . . H(k) and UNGBR returns the first n columns of Q, where m >= n >= k; if m < k, Q = H(1) H(2) . . . H(m-1) and UNGBR returns Q as an M-by-M matrix. If VECT = 'P', A is assumed to have been a K-by-N matrix, and PH is of order N: if k < n, PH = G(k) . . . G(2) G(1) and UNGBR returns the first m rows of PH, where n >= m >= k; if k >= n, PH = G(n-1) . . . G(2) G(1) and UNGBR returns PH as an N-by-N matrix.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | vect | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | k | |||
| complex(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=sp), | intent(in) | :: | tau(*) | |||
| complex(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | vect | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | k | |||
| complex(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=dp), | intent(in) | :: | tau(*) | |||
| complex(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
CUNGBR generates one of the complex unitary matrices Q or PH determined by CGEBRD when reducing a complex matrix A to bidiagonal form: A = Q * B * PH. Q and PH are defined as products of elementary reflectors H(i) or G(i) respectively. If VECT = 'Q', A is assumed to have been an M-by-K matrix, and Q is of order M: if m >= k, Q = H(1) H(2) . . . H(k) and CUNGBR returns the first n columns of Q, where m >= n >= k; if m < k, Q = H(1) H(2) . . . H(m-1) and CUNGBR returns Q as an M-by-M matrix. If VECT = 'P', A is assumed to have been a K-by-N matrix, and PH is of order N: if k < n, PH = G(k) . . . G(2) G(1) and CUNGBR returns the first m rows of PH, where n >= m >= k; if k >= n, PH = G(n-1) . . . G(2) G(1) and CUNGBR returns PH as an N-by-N matrix.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | vect | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | k | |||
| complex(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=sp), | intent(in) | :: | tau(*) | |||
| complex(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
ZUNGBR generates one of the complex unitary matrices Q or PH determined by ZGEBRD when reducing a complex matrix A to bidiagonal form: A = Q * B * PH. Q and PH are defined as products of elementary reflectors H(i) or G(i) respectively. If VECT = 'Q', A is assumed to have been an M-by-K matrix, and Q is of order M: if m >= k, Q = H(1) H(2) . . . H(k) and ZUNGBR returns the first n columns of Q, where m >= n >= k; if m < k, Q = H(1) H(2) . . . H(m-1) and ZUNGBR returns Q as an M-by-M matrix. If VECT = 'P', A is assumed to have been a K-by-N matrix, and PH is of order N: if k < n, PH = G(k) . . . G(2) G(1) and ZUNGBR returns the first m rows of PH, where n >= m >= k; if k >= n, PH = G(n-1) . . . G(2) G(1) and ZUNGBR returns PH as an N-by-N matrix.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | vect | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | k | |||
| complex(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=dp), | intent(in) | :: | tau(*) | |||
| complex(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
UNGHR generates a complex unitary matrix Q which is defined as the product of IHI-ILO elementary reflectors of order N, as returned by CGEHRD: Q = H(ilo) H(ilo+1) . . . H(ihi-1).
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | ilo | |||
| integer(kind=ilp), | intent(in) | :: | ihi | |||
| complex(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=sp), | intent(in) | :: | tau(*) | |||
| complex(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | ilo | |||
| integer(kind=ilp), | intent(in) | :: | ihi | |||
| complex(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=dp), | intent(in) | :: | tau(*) | |||
| complex(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
CUNGHR generates a complex unitary matrix Q which is defined as the product of IHI-ILO elementary reflectors of order N, as returned by CGEHRD: Q = H(ilo) H(ilo+1) . . . H(ihi-1).
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | ilo | |||
| integer(kind=ilp), | intent(in) | :: | ihi | |||
| complex(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=sp), | intent(in) | :: | tau(*) | |||
| complex(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
ZUNGHR generates a complex unitary matrix Q which is defined as the product of IHI-ILO elementary reflectors of order N, as returned by ZGEHRD: Q = H(ilo) H(ilo+1) . . . H(ihi-1).
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | ilo | |||
| integer(kind=ilp), | intent(in) | :: | ihi | |||
| complex(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=dp), | intent(in) | :: | tau(*) | |||
| complex(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
UNGLQ generates an M-by-N complex matrix Q with orthonormal rows, which is defined as the first M rows of a product of K elementary reflectors of order N Q = H(k)H . . . H(2)H H(1)**H as returned by CGELQF.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | k | |||
| complex(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=sp), | intent(in) | :: | tau(*) | |||
| complex(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | k | |||
| complex(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=dp), | intent(in) | :: | tau(*) | |||
| complex(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
CUNGLQ generates an M-by-N complex matrix Q with orthonormal rows, which is defined as the first M rows of a product of K elementary reflectors of order N Q = H(k)H . . . H(2)H H(1)**H as returned by CGELQF.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | k | |||
| complex(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=sp), | intent(in) | :: | tau(*) | |||
| complex(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
ZUNGLQ generates an M-by-N complex matrix Q with orthonormal rows, which is defined as the first M rows of a product of K elementary reflectors of order N Q = H(k)H . . . H(2)H H(1)**H as returned by ZGELQF.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | k | |||
| complex(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=dp), | intent(in) | :: | tau(*) | |||
| complex(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
UNGQL generates an M-by-N complex matrix Q with orthonormal columns, which is defined as the last N columns of a product of K elementary reflectors of order M Q = H(k) . . . H(2) H(1) as returned by CGEQLF.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | k | |||
| complex(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=sp), | intent(in) | :: | tau(*) | |||
| complex(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | k | |||
| complex(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=dp), | intent(in) | :: | tau(*) | |||
| complex(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
CUNGQL generates an M-by-N complex matrix Q with orthonormal columns, which is defined as the last N columns of a product of K elementary reflectors of order M Q = H(k) . . . H(2) H(1) as returned by CGEQLF.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | k | |||
| complex(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=sp), | intent(in) | :: | tau(*) | |||
| complex(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
ZUNGQL generates an M-by-N complex matrix Q with orthonormal columns, which is defined as the last N columns of a product of K elementary reflectors of order M Q = H(k) . . . H(2) H(1) as returned by ZGEQLF.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | k | |||
| complex(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=dp), | intent(in) | :: | tau(*) | |||
| complex(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
UNGQR generates an M-by-N complex matrix Q with orthonormal columns, which is defined as the first N columns of a product of K elementary reflectors of order M Q = H(1) H(2) . . . H(k) as returned by CGEQRF.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | k | |||
| complex(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=sp), | intent(in) | :: | tau(*) | |||
| complex(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | k | |||
| complex(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=dp), | intent(in) | :: | tau(*) | |||
| complex(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
CUNGQR generates an M-by-N complex matrix Q with orthonormal columns, which is defined as the first N columns of a product of K elementary reflectors of order M Q = H(1) H(2) . . . H(k) as returned by CGEQRF.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | k | |||
| complex(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=sp), | intent(in) | :: | tau(*) | |||
| complex(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
ZUNGQR generates an M-by-N complex matrix Q with orthonormal columns, which is defined as the first N columns of a product of K elementary reflectors of order M Q = H(1) H(2) . . . H(k) as returned by ZGEQRF.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | k | |||
| complex(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=dp), | intent(in) | :: | tau(*) | |||
| complex(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
UNGRQ generates an M-by-N complex matrix Q with orthonormal rows, which is defined as the last M rows of a product of K elementary reflectors of order N Q = H(1)H H(2)H . . . H(k)**H as returned by CGERQF.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | k | |||
| complex(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=sp), | intent(in) | :: | tau(*) | |||
| complex(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | k | |||
| complex(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=dp), | intent(in) | :: | tau(*) | |||
| complex(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
CUNGRQ generates an M-by-N complex matrix Q with orthonormal rows, which is defined as the last M rows of a product of K elementary reflectors of order N Q = H(1)H H(2)H . . . H(k)**H as returned by CGERQF.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | k | |||
| complex(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=sp), | intent(in) | :: | tau(*) | |||
| complex(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
ZUNGRQ generates an M-by-N complex matrix Q with orthonormal rows, which is defined as the last M rows of a product of K elementary reflectors of order N Q = H(1)H H(2)H . . . H(k)**H as returned by ZGERQF.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | k | |||
| complex(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=dp), | intent(in) | :: | tau(*) | |||
| complex(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
UNGTR generates a complex unitary matrix Q which is defined as the product of n-1 elementary reflectors of order N, as returned by CHETRD: if UPLO = 'U', Q = H(n-1) . . . H(2) H(1), if UPLO = 'L', Q = H(1) H(2) . . . H(n-1).
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=sp), | intent(in) | :: | tau(*) | |||
| complex(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=dp), | intent(in) | :: | tau(*) | |||
| complex(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
CUNGTR generates a complex unitary matrix Q which is defined as the product of n-1 elementary reflectors of order N, as returned by CHETRD: if UPLO = 'U', Q = H(n-1) . . . H(2) H(1), if UPLO = 'L', Q = H(1) H(2) . . . H(n-1).
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=sp), | intent(in) | :: | tau(*) | |||
| complex(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
ZUNGTR generates a complex unitary matrix Q which is defined as the product of n-1 elementary reflectors of order N, as returned by ZHETRD: if UPLO = 'U', Q = H(n-1) . . . H(2) H(1), if UPLO = 'L', Q = H(1) H(2) . . . H(n-1).
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=dp), | intent(in) | :: | tau(*) | |||
| complex(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
UNGTSQR generates an M-by-N complex matrix Q_out with orthonormal columns, which are the first N columns of a product of comlpex unitary matrices of order M which are returned by CLATSQR Q_out = first_N_columns_of( Q(1)_in * Q(2)_in * ... * Q(k)_in ). See the documentation for CLATSQR.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | mb | |||
| integer(kind=ilp), | intent(in) | :: | nb | |||
| complex(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=sp), | intent(in) | :: | t(ldt,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldt | |||
| complex(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | mb | |||
| integer(kind=ilp), | intent(in) | :: | nb | |||
| complex(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=dp), | intent(in) | :: | t(ldt,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldt | |||
| complex(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
CUNGTSQR generates an M-by-N complex matrix Q_out with orthonormal columns, which are the first N columns of a product of comlpex unitary matrices of order M which are returned by CLATSQR Q_out = first_N_columns_of( Q(1)_in * Q(2)_in * ... * Q(k)_in ). See the documentation for CLATSQR.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | mb | |||
| integer(kind=ilp), | intent(in) | :: | nb | |||
| complex(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=sp), | intent(in) | :: | t(ldt,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldt | |||
| complex(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
ZUNGTSQR generates an M-by-N complex matrix Q_out with orthonormal columns, which are the first N columns of a product of comlpex unitary matrices of order M which are returned by ZLATSQR Q_out = first_N_columns_of( Q(1)_in * Q(2)_in * ... * Q(k)_in ). See the documentation for ZLATSQR.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | mb | |||
| integer(kind=ilp), | intent(in) | :: | nb | |||
| complex(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=dp), | intent(in) | :: | t(ldt,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldt | |||
| complex(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
UNGTSQR_ROW generates an M-by-N complex matrix Q_out with orthonormal columns from the output of CLATSQR. These N orthonormal columns are the first N columns of a product of complex unitary matrices Q(k)_in of order M, which are returned by CLATSQR in a special format. Q_out = first_N_columns_of( Q(1)_in * Q(2)_in * ... * Q(k)_in ). The input matrices Q(k)_in are stored in row and column blocks in A. See the documentation of CLATSQR for more details on the format of Q(k)_in, where each Q(k)_in is represented by block Householder transformations. This routine calls an auxiliary routine CLARFB_GETT, where the computation is performed on each individual block. The algorithm first sweeps NB-sized column blocks from the right to left starting in the bottom row block and continues to the top row block (hence _ROW in the routine name). This sweep is in reverse order of the order in which CLATSQR generates the output blocks.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | mb | |||
| integer(kind=ilp), | intent(in) | :: | nb | |||
| complex(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=sp), | intent(in) | :: | t(ldt,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldt | |||
| complex(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | mb | |||
| integer(kind=ilp), | intent(in) | :: | nb | |||
| complex(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=dp), | intent(in) | :: | t(ldt,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldt | |||
| complex(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
CUNGTSQR_ROW generates an M-by-N complex matrix Q_out with orthonormal columns from the output of CLATSQR. These N orthonormal columns are the first N columns of a product of complex unitary matrices Q(k)_in of order M, which are returned by CLATSQR in a special format. Q_out = first_N_columns_of( Q(1)_in * Q(2)_in * ... * Q(k)_in ). The input matrices Q(k)_in are stored in row and column blocks in A. See the documentation of CLATSQR for more details on the format of Q(k)_in, where each Q(k)_in is represented by block Householder transformations. This routine calls an auxiliary routine CLARFB_GETT, where the computation is performed on each individual block. The algorithm first sweeps NB-sized column blocks from the right to left starting in the bottom row block and continues to the top row block (hence _ROW in the routine name). This sweep is in reverse order of the order in which CLATSQR generates the output blocks.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | mb | |||
| integer(kind=ilp), | intent(in) | :: | nb | |||
| complex(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=sp), | intent(in) | :: | t(ldt,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldt | |||
| complex(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
ZUNGTSQR_ROW generates an M-by-N complex matrix Q_out with orthonormal columns from the output of ZLATSQR. These N orthonormal columns are the first N columns of a product of complex unitary matrices Q(k)_in of order M, which are returned by ZLATSQR in a special format. Q_out = first_N_columns_of( Q(1)_in * Q(2)_in * ... * Q(k)_in ). The input matrices Q(k)_in are stored in row and column blocks in A. See the documentation of ZLATSQR for more details on the format of Q(k)_in, where each Q(k)_in is represented by block Householder transformations. This routine calls an auxiliary routine ZLARFB_GETT, where the computation is performed on each individual block. The algorithm first sweeps NB-sized column blocks from the right to left starting in the bottom row block and continues to the top row block (hence _ROW in the routine name). This sweep is in reverse order of the order in which ZLATSQR generates the output blocks.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | mb | |||
| integer(kind=ilp), | intent(in) | :: | nb | |||
| complex(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=dp), | intent(in) | :: | t(ldt,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldt | |||
| complex(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
UNHR_COL takes an M-by-N complex matrix Q_in with orthonormal columns as input, stored in A, and performs Householder Reconstruction (HR), i.e. reconstructs Householder vectors V(i) implicitly representing another M-by-N matrix Q_out, with the property that Q_in = Q_out*S, where S is an N-by-N diagonal matrix with diagonal entries equal to +1 or -1. The Householder vectors (columns V(i) of V) are stored in A on output, and the diagonal entries of S are stored in D. Block reflectors are also returned in T (same output format as CGEQRT).
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nb | |||
| complex(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=sp), | intent(out) | :: | t(ldt,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldt | |||
| complex(kind=sp), | intent(out) | :: | d(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nb | |||
| complex(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=dp), | intent(out) | :: | t(ldt,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldt | |||
| complex(kind=dp), | intent(out) | :: | d(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
CUNHR_COL takes an M-by-N complex matrix Q_in with orthonormal columns as input, stored in A, and performs Householder Reconstruction (HR), i.e. reconstructs Householder vectors V(i) implicitly representing another M-by-N matrix Q_out, with the property that Q_in = Q_out*S, where S is an N-by-N diagonal matrix with diagonal entries equal to +1 or -1. The Householder vectors (columns V(i) of V) are stored in A on output, and the diagonal entries of S are stored in D. Block reflectors are also returned in T (same output format as CGEQRT).
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nb | |||
| complex(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=sp), | intent(out) | :: | t(ldt,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldt | |||
| complex(kind=sp), | intent(out) | :: | d(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
ZUNHR_COL takes an M-by-N complex matrix Q_in with orthonormal columns as input, stored in A, and performs Householder Reconstruction (HR), i.e. reconstructs Householder vectors V(i) implicitly representing another M-by-N matrix Q_out, with the property that Q_in = Q_out*S, where S is an N-by-N diagonal matrix with diagonal entries equal to +1 or -1. The Householder vectors (columns V(i) of V) are stored in A on output, and the diagonal entries of S are stored in D. Block reflectors are also returned in T (same output format as ZGEQRT).
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | nb | |||
| complex(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=dp), | intent(out) | :: | t(ldt,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldt | |||
| complex(kind=dp), | intent(out) | :: | d(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
UNM2L overwrites the general complex m-by-n matrix C with Q * C if SIDE = 'L' and TRANS = 'N', or QH* C if SIDE = 'L' and TRANS = 'C', or C * Q if SIDE = 'R' and TRANS = 'N', or C * QH if SIDE = 'R' and TRANS = 'C', where Q is a complex unitary matrix defined as the product of k elementary reflectors Q = H(k) . . . H(2) H(1) as returned by CGEQLF. Q is of order m if SIDE = 'L' and of order n if SIDE = 'R'.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | side | |||
| character, | intent(in) | :: | trans | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | k | |||
| complex(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=sp), | intent(in) | :: | tau(*) | |||
| complex(kind=sp), | intent(inout) | :: | c(ldc,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldc | |||
| complex(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | side | |||
| character, | intent(in) | :: | trans | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | k | |||
| complex(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=dp), | intent(in) | :: | tau(*) | |||
| complex(kind=dp), | intent(inout) | :: | c(ldc,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldc | |||
| complex(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
CUNM2L overwrites the general complex m-by-n matrix C with Q * C if SIDE = 'L' and TRANS = 'N', or QH* C if SIDE = 'L' and TRANS = 'C', or C * Q if SIDE = 'R' and TRANS = 'N', or C * QH if SIDE = 'R' and TRANS = 'C', where Q is a complex unitary matrix defined as the product of k elementary reflectors Q = H(k) . . . H(2) H(1) as returned by CGEQLF. Q is of order m if SIDE = 'L' and of order n if SIDE = 'R'.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | side | |||
| character, | intent(in) | :: | trans | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | k | |||
| complex(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=sp), | intent(in) | :: | tau(*) | |||
| complex(kind=sp), | intent(inout) | :: | c(ldc,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldc | |||
| complex(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
ZUNM2L overwrites the general complex m-by-n matrix C with Q * C if SIDE = 'L' and TRANS = 'N', or QH* C if SIDE = 'L' and TRANS = 'C', or C * Q if SIDE = 'R' and TRANS = 'N', or C * QH if SIDE = 'R' and TRANS = 'C', where Q is a complex unitary matrix defined as the product of k elementary reflectors Q = H(k) . . . H(2) H(1) as returned by ZGEQLF. Q is of order m if SIDE = 'L' and of order n if SIDE = 'R'.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | side | |||
| character, | intent(in) | :: | trans | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | k | |||
| complex(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=dp), | intent(in) | :: | tau(*) | |||
| complex(kind=dp), | intent(inout) | :: | c(ldc,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldc | |||
| complex(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
UNM2R overwrites the general complex m-by-n matrix C with Q * C if SIDE = 'L' and TRANS = 'N', or QH* C if SIDE = 'L' and TRANS = 'C', or C * Q if SIDE = 'R' and TRANS = 'N', or C * QH if SIDE = 'R' and TRANS = 'C', where Q is a complex unitary matrix defined as the product of k elementary reflectors Q = H(1) H(2) . . . H(k) as returned by CGEQRF. Q is of order m if SIDE = 'L' and of order n if SIDE = 'R'.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | side | |||
| character, | intent(in) | :: | trans | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | k | |||
| complex(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=sp), | intent(in) | :: | tau(*) | |||
| complex(kind=sp), | intent(inout) | :: | c(ldc,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldc | |||
| complex(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | side | |||
| character, | intent(in) | :: | trans | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | k | |||
| complex(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=dp), | intent(in) | :: | tau(*) | |||
| complex(kind=dp), | intent(inout) | :: | c(ldc,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldc | |||
| complex(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
CUNM2R overwrites the general complex m-by-n matrix C with Q * C if SIDE = 'L' and TRANS = 'N', or QH* C if SIDE = 'L' and TRANS = 'C', or C * Q if SIDE = 'R' and TRANS = 'N', or C * QH if SIDE = 'R' and TRANS = 'C', where Q is a complex unitary matrix defined as the product of k elementary reflectors Q = H(1) H(2) . . . H(k) as returned by CGEQRF. Q is of order m if SIDE = 'L' and of order n if SIDE = 'R'.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | side | |||
| character, | intent(in) | :: | trans | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | k | |||
| complex(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=sp), | intent(in) | :: | tau(*) | |||
| complex(kind=sp), | intent(inout) | :: | c(ldc,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldc | |||
| complex(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
ZUNM2R overwrites the general complex m-by-n matrix C with Q * C if SIDE = 'L' and TRANS = 'N', or QH* C if SIDE = 'L' and TRANS = 'C', or C * Q if SIDE = 'R' and TRANS = 'N', or C * QH if SIDE = 'R' and TRANS = 'C', where Q is a complex unitary matrix defined as the product of k elementary reflectors Q = H(1) H(2) . . . H(k) as returned by ZGEQRF. Q is of order m if SIDE = 'L' and of order n if SIDE = 'R'.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | side | |||
| character, | intent(in) | :: | trans | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | k | |||
| complex(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=dp), | intent(in) | :: | tau(*) | |||
| complex(kind=dp), | intent(inout) | :: | c(ldc,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldc | |||
| complex(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
If VECT = 'Q', UNMBR: overwrites the general complex M-by-N matrix C with SIDE = 'L' SIDE = 'R' TRANS = 'N': Q * C C * Q TRANS = 'C': QH * C C * QH If VECT = 'P', UNMBR overwrites the general complex M-by-N matrix C with SIDE = 'L' SIDE = 'R' TRANS = 'N': P * C C * P TRANS = 'C': PH * C C * PH Here Q and PH are the unitary matrices determined by CGEBRD when reducing a complex matrix A to bidiagonal form: A = Q * B * PH. Q and PH are defined as products of elementary reflectors H(i) and G(i) respectively. Let nq = m if SIDE = 'L' and nq = n if SIDE = 'R'. Thus nq is the order of the unitary matrix Q or PH that is applied. If VECT = 'Q', A is assumed to have been an NQ-by-K matrix: if nq >= k, Q = H(1) H(2) . . . H(k); if nq < k, Q = H(1) H(2) . . . H(nq-1). If VECT = 'P', A is assumed to have been a K-by-NQ matrix: if k < nq, P = G(1) G(2) . . . G(k); if k >= nq, P = G(1) G(2) . . . G(nq-1).
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | vect | |||
| character, | intent(in) | :: | side | |||
| character, | intent(in) | :: | trans | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | k | |||
| complex(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=sp), | intent(in) | :: | tau(*) | |||
| complex(kind=sp), | intent(inout) | :: | c(ldc,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldc | |||
| complex(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | vect | |||
| character, | intent(in) | :: | side | |||
| character, | intent(in) | :: | trans | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | k | |||
| complex(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=dp), | intent(in) | :: | tau(*) | |||
| complex(kind=dp), | intent(inout) | :: | c(ldc,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldc | |||
| complex(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
If VECT = 'Q', CUNMBR: overwrites the general complex M-by-N matrix C with SIDE = 'L' SIDE = 'R' TRANS = 'N': Q * C C * Q TRANS = 'C': QH * C C * QH If VECT = 'P', CUNMBR overwrites the general complex M-by-N matrix C with SIDE = 'L' SIDE = 'R' TRANS = 'N': P * C C * P TRANS = 'C': PH * C C * PH Here Q and PH are the unitary matrices determined by CGEBRD when reducing a complex matrix A to bidiagonal form: A = Q * B * PH. Q and PH are defined as products of elementary reflectors H(i) and G(i) respectively. Let nq = m if SIDE = 'L' and nq = n if SIDE = 'R'. Thus nq is the order of the unitary matrix Q or PH that is applied. If VECT = 'Q', A is assumed to have been an NQ-by-K matrix: if nq >= k, Q = H(1) H(2) . . . H(k); if nq < k, Q = H(1) H(2) . . . H(nq-1). If VECT = 'P', A is assumed to have been a K-by-NQ matrix: if k < nq, P = G(1) G(2) . . . G(k); if k >= nq, P = G(1) G(2) . . . G(nq-1).
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | vect | |||
| character, | intent(in) | :: | side | |||
| character, | intent(in) | :: | trans | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | k | |||
| complex(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=sp), | intent(in) | :: | tau(*) | |||
| complex(kind=sp), | intent(inout) | :: | c(ldc,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldc | |||
| complex(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
If VECT = 'Q', ZUNMBR: overwrites the general complex M-by-N matrix C with SIDE = 'L' SIDE = 'R' TRANS = 'N': Q * C C * Q TRANS = 'C': QH * C C * QH If VECT = 'P', ZUNMBR overwrites the general complex M-by-N matrix C with SIDE = 'L' SIDE = 'R' TRANS = 'N': P * C C * P TRANS = 'C': PH * C C * PH Here Q and PH are the unitary matrices determined by ZGEBRD when reducing a complex matrix A to bidiagonal form: A = Q * B * PH. Q and PH are defined as products of elementary reflectors H(i) and G(i) respectively. Let nq = m if SIDE = 'L' and nq = n if SIDE = 'R'. Thus nq is the order of the unitary matrix Q or PH that is applied. If VECT = 'Q', A is assumed to have been an NQ-by-K matrix: if nq >= k, Q = H(1) H(2) . . . H(k); if nq < k, Q = H(1) H(2) . . . H(nq-1). If VECT = 'P', A is assumed to have been a K-by-NQ matrix: if k < nq, P = G(1) G(2) . . . G(k); if k >= nq, P = G(1) G(2) . . . G(nq-1).
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | vect | |||
| character, | intent(in) | :: | side | |||
| character, | intent(in) | :: | trans | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | k | |||
| complex(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=dp), | intent(in) | :: | tau(*) | |||
| complex(kind=dp), | intent(inout) | :: | c(ldc,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldc | |||
| complex(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
UNMHR overwrites the general complex M-by-N matrix C with SIDE = 'L' SIDE = 'R' TRANS = 'N': Q * C C * Q TRANS = 'C': QH * C C * QH where Q is a complex unitary matrix of order nq, with nq = m if SIDE = 'L' and nq = n if SIDE = 'R'. Q is defined as the product of IHI-ILO elementary reflectors, as returned by CGEHRD: Q = H(ilo) H(ilo+1) . . . H(ihi-1).
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | side | |||
| character, | intent(in) | :: | trans | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | ilo | |||
| integer(kind=ilp), | intent(in) | :: | ihi | |||
| complex(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=sp), | intent(in) | :: | tau(*) | |||
| complex(kind=sp), | intent(inout) | :: | c(ldc,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldc | |||
| complex(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | side | |||
| character, | intent(in) | :: | trans | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | ilo | |||
| integer(kind=ilp), | intent(in) | :: | ihi | |||
| complex(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=dp), | intent(in) | :: | tau(*) | |||
| complex(kind=dp), | intent(inout) | :: | c(ldc,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldc | |||
| complex(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
CUNMHR overwrites the general complex M-by-N matrix C with SIDE = 'L' SIDE = 'R' TRANS = 'N': Q * C C * Q TRANS = 'C': QH * C C * QH where Q is a complex unitary matrix of order nq, with nq = m if SIDE = 'L' and nq = n if SIDE = 'R'. Q is defined as the product of IHI-ILO elementary reflectors, as returned by CGEHRD: Q = H(ilo) H(ilo+1) . . . H(ihi-1).
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | side | |||
| character, | intent(in) | :: | trans | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | ilo | |||
| integer(kind=ilp), | intent(in) | :: | ihi | |||
| complex(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=sp), | intent(in) | :: | tau(*) | |||
| complex(kind=sp), | intent(inout) | :: | c(ldc,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldc | |||
| complex(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
ZUNMHR overwrites the general complex M-by-N matrix C with SIDE = 'L' SIDE = 'R' TRANS = 'N': Q * C C * Q TRANS = 'C': QH * C C * QH where Q is a complex unitary matrix of order nq, with nq = m if SIDE = 'L' and nq = n if SIDE = 'R'. Q is defined as the product of IHI-ILO elementary reflectors, as returned by ZGEHRD: Q = H(ilo) H(ilo+1) . . . H(ihi-1).
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | side | |||
| character, | intent(in) | :: | trans | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | ilo | |||
| integer(kind=ilp), | intent(in) | :: | ihi | |||
| complex(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=dp), | intent(in) | :: | tau(*) | |||
| complex(kind=dp), | intent(inout) | :: | c(ldc,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldc | |||
| complex(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
UNMLQ overwrites the general complex M-by-N matrix C with SIDE = 'L' SIDE = 'R' TRANS = 'N': Q * C C * Q TRANS = 'C': QH * C C * QH where Q is a complex unitary matrix defined as the product of k elementary reflectors Q = H(k)H . . . H(2)H H(1)**H as returned by CGELQF. Q is of order M if SIDE = 'L' and of order N if SIDE = 'R'.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | side | |||
| character, | intent(in) | :: | trans | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | k | |||
| complex(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=sp), | intent(in) | :: | tau(*) | |||
| complex(kind=sp), | intent(inout) | :: | c(ldc,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldc | |||
| complex(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | side | |||
| character, | intent(in) | :: | trans | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | k | |||
| complex(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=dp), | intent(in) | :: | tau(*) | |||
| complex(kind=dp), | intent(inout) | :: | c(ldc,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldc | |||
| complex(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
CUNMLQ overwrites the general complex M-by-N matrix C with SIDE = 'L' SIDE = 'R' TRANS = 'N': Q * C C * Q TRANS = 'C': QH * C C * QH where Q is a complex unitary matrix defined as the product of k elementary reflectors Q = H(k)H . . . H(2)H H(1)**H as returned by CGELQF. Q is of order M if SIDE = 'L' and of order N if SIDE = 'R'.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | side | |||
| character, | intent(in) | :: | trans | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | k | |||
| complex(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=sp), | intent(in) | :: | tau(*) | |||
| complex(kind=sp), | intent(inout) | :: | c(ldc,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldc | |||
| complex(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
ZUNMLQ overwrites the general complex M-by-N matrix C with SIDE = 'L' SIDE = 'R' TRANS = 'N': Q * C C * Q TRANS = 'C': QH * C C * QH where Q is a complex unitary matrix defined as the product of k elementary reflectors Q = H(k)H . . . H(2)H H(1)**H as returned by ZGELQF. Q is of order M if SIDE = 'L' and of order N if SIDE = 'R'.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | side | |||
| character, | intent(in) | :: | trans | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | k | |||
| complex(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=dp), | intent(in) | :: | tau(*) | |||
| complex(kind=dp), | intent(inout) | :: | c(ldc,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldc | |||
| complex(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
UNMQL overwrites the general complex M-by-N matrix C with SIDE = 'L' SIDE = 'R' TRANS = 'N': Q * C C * Q TRANS = 'C': QH * C C * QH where Q is a complex unitary matrix defined as the product of k elementary reflectors Q = H(k) . . . H(2) H(1) as returned by CGEQLF. Q is of order M if SIDE = 'L' and of order N if SIDE = 'R'.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | side | |||
| character, | intent(in) | :: | trans | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | k | |||
| complex(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=sp), | intent(in) | :: | tau(*) | |||
| complex(kind=sp), | intent(inout) | :: | c(ldc,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldc | |||
| complex(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | side | |||
| character, | intent(in) | :: | trans | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | k | |||
| complex(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=dp), | intent(in) | :: | tau(*) | |||
| complex(kind=dp), | intent(inout) | :: | c(ldc,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldc | |||
| complex(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
CUNMQL overwrites the general complex M-by-N matrix C with SIDE = 'L' SIDE = 'R' TRANS = 'N': Q * C C * Q TRANS = 'C': QH * C C * QH where Q is a complex unitary matrix defined as the product of k elementary reflectors Q = H(k) . . . H(2) H(1) as returned by CGEQLF. Q is of order M if SIDE = 'L' and of order N if SIDE = 'R'.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | side | |||
| character, | intent(in) | :: | trans | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | k | |||
| complex(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=sp), | intent(in) | :: | tau(*) | |||
| complex(kind=sp), | intent(inout) | :: | c(ldc,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldc | |||
| complex(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
ZUNMQL overwrites the general complex M-by-N matrix C with SIDE = 'L' SIDE = 'R' TRANS = 'N': Q * C C * Q TRANS = 'C': QH * C C * QH where Q is a complex unitary matrix defined as the product of k elementary reflectors Q = H(k) . . . H(2) H(1) as returned by ZGEQLF. Q is of order M if SIDE = 'L' and of order N if SIDE = 'R'.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | side | |||
| character, | intent(in) | :: | trans | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | k | |||
| complex(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=dp), | intent(in) | :: | tau(*) | |||
| complex(kind=dp), | intent(inout) | :: | c(ldc,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldc | |||
| complex(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
UNMQR overwrites the general complex M-by-N matrix C with SIDE = 'L' SIDE = 'R' TRANS = 'N': Q * C C * Q TRANS = 'C': QH * C C * QH where Q is a complex unitary matrix defined as the product of k elementary reflectors Q = H(1) H(2) . . . H(k) as returned by CGEQRF. Q is of order M if SIDE = 'L' and of order N if SIDE = 'R'.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | side | |||
| character, | intent(in) | :: | trans | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | k | |||
| complex(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=sp), | intent(in) | :: | tau(*) | |||
| complex(kind=sp), | intent(inout) | :: | c(ldc,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldc | |||
| complex(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | side | |||
| character, | intent(in) | :: | trans | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | k | |||
| complex(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=dp), | intent(in) | :: | tau(*) | |||
| complex(kind=dp), | intent(inout) | :: | c(ldc,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldc | |||
| complex(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
CUNMQR overwrites the general complex M-by-N matrix C with SIDE = 'L' SIDE = 'R' TRANS = 'N': Q * C C * Q TRANS = 'C': QH * C C * QH where Q is a complex unitary matrix defined as the product of k elementary reflectors Q = H(1) H(2) . . . H(k) as returned by CGEQRF. Q is of order M if SIDE = 'L' and of order N if SIDE = 'R'.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | side | |||
| character, | intent(in) | :: | trans | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | k | |||
| complex(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=sp), | intent(in) | :: | tau(*) | |||
| complex(kind=sp), | intent(inout) | :: | c(ldc,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldc | |||
| complex(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
ZUNMQR overwrites the general complex M-by-N matrix C with SIDE = 'L' SIDE = 'R' TRANS = 'N': Q * C C * Q TRANS = 'C': QH * C C * QH where Q is a complex unitary matrix defined as the product of k elementary reflectors Q = H(1) H(2) . . . H(k) as returned by ZGEQRF. Q is of order M if SIDE = 'L' and of order N if SIDE = 'R'.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | side | |||
| character, | intent(in) | :: | trans | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | k | |||
| complex(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=dp), | intent(in) | :: | tau(*) | |||
| complex(kind=dp), | intent(inout) | :: | c(ldc,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldc | |||
| complex(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
UNMRQ overwrites the general complex M-by-N matrix C with SIDE = 'L' SIDE = 'R' TRANS = 'N': Q * C C * Q TRANS = 'C': QH * C C * QH where Q is a complex unitary matrix defined as the product of k elementary reflectors Q = H(1)H H(2)H . . . H(k)**H as returned by CGERQF. Q is of order M if SIDE = 'L' and of order N if SIDE = 'R'.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | side | |||
| character, | intent(in) | :: | trans | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | k | |||
| complex(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=sp), | intent(in) | :: | tau(*) | |||
| complex(kind=sp), | intent(inout) | :: | c(ldc,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldc | |||
| complex(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | side | |||
| character, | intent(in) | :: | trans | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | k | |||
| complex(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=dp), | intent(in) | :: | tau(*) | |||
| complex(kind=dp), | intent(inout) | :: | c(ldc,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldc | |||
| complex(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
CUNMRQ overwrites the general complex M-by-N matrix C with SIDE = 'L' SIDE = 'R' TRANS = 'N': Q * C C * Q TRANS = 'C': QH * C C * QH where Q is a complex unitary matrix defined as the product of k elementary reflectors Q = H(1)H H(2)H . . . H(k)**H as returned by CGERQF. Q is of order M if SIDE = 'L' and of order N if SIDE = 'R'.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | side | |||
| character, | intent(in) | :: | trans | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | k | |||
| complex(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=sp), | intent(in) | :: | tau(*) | |||
| complex(kind=sp), | intent(inout) | :: | c(ldc,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldc | |||
| complex(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
ZUNMRQ overwrites the general complex M-by-N matrix C with SIDE = 'L' SIDE = 'R' TRANS = 'N': Q * C C * Q TRANS = 'C': QH * C C * QH where Q is a complex unitary matrix defined as the product of k elementary reflectors Q = H(1)H H(2)H . . . H(k)**H as returned by ZGERQF. Q is of order M if SIDE = 'L' and of order N if SIDE = 'R'.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | side | |||
| character, | intent(in) | :: | trans | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | k | |||
| complex(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=dp), | intent(in) | :: | tau(*) | |||
| complex(kind=dp), | intent(inout) | :: | c(ldc,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldc | |||
| complex(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
UNMRZ overwrites the general complex M-by-N matrix C with SIDE = 'L' SIDE = 'R' TRANS = 'N': Q * C C * Q TRANS = 'C': QH * C C * QH where Q is a complex unitary matrix defined as the product of k elementary reflectors Q = H(1) H(2) . . . H(k) as returned by CTZRZF. Q is of order M if SIDE = 'L' and of order N if SIDE = 'R'.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | side | |||
| character, | intent(in) | :: | trans | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | k | |||
| integer(kind=ilp), | intent(in) | :: | l | |||
| complex(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=sp), | intent(in) | :: | tau(*) | |||
| complex(kind=sp), | intent(inout) | :: | c(ldc,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldc | |||
| complex(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | side | |||
| character, | intent(in) | :: | trans | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | k | |||
| integer(kind=ilp), | intent(in) | :: | l | |||
| complex(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=dp), | intent(in) | :: | tau(*) | |||
| complex(kind=dp), | intent(inout) | :: | c(ldc,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldc | |||
| complex(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
CUNMRZ overwrites the general complex M-by-N matrix C with SIDE = 'L' SIDE = 'R' TRANS = 'N': Q * C C * Q TRANS = 'C': QH * C C * QH where Q is a complex unitary matrix defined as the product of k elementary reflectors Q = H(1) H(2) . . . H(k) as returned by CTZRZF. Q is of order M if SIDE = 'L' and of order N if SIDE = 'R'.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | side | |||
| character, | intent(in) | :: | trans | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | k | |||
| integer(kind=ilp), | intent(in) | :: | l | |||
| complex(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=sp), | intent(in) | :: | tau(*) | |||
| complex(kind=sp), | intent(inout) | :: | c(ldc,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldc | |||
| complex(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
ZUNMRZ overwrites the general complex M-by-N matrix C with SIDE = 'L' SIDE = 'R' TRANS = 'N': Q * C C * Q TRANS = 'C': QH * C C * QH where Q is a complex unitary matrix defined as the product of k elementary reflectors Q = H(1) H(2) . . . H(k) as returned by ZTZRZF. Q is of order M if SIDE = 'L' and of order N if SIDE = 'R'.
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | side | |||
| character, | intent(in) | :: | trans | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| integer(kind=ilp), | intent(in) | :: | k | |||
| integer(kind=ilp), | intent(in) | :: | l | |||
| complex(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=dp), | intent(in) | :: | tau(*) | |||
| complex(kind=dp), | intent(inout) | :: | c(ldc,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldc | |||
| complex(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
UNMTR overwrites the general complex M-by-N matrix C with SIDE = 'L' SIDE = 'R' TRANS = 'N': Q * C C * Q TRANS = 'C': QH * C C * QH where Q is a complex unitary matrix of order nq, with nq = m if SIDE = 'L' and nq = n if SIDE = 'R'. Q is defined as the product of nq-1 elementary reflectors, as returned by CHETRD: if UPLO = 'U', Q = H(nq-1) . . . H(2) H(1); if UPLO = 'L', Q = H(1) H(2) . . . H(nq-1).
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | side | |||
| character, | intent(in) | :: | uplo | |||
| character, | intent(in) | :: | trans | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=sp), | intent(in) | :: | tau(*) | |||
| complex(kind=sp), | intent(inout) | :: | c(ldc,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldc | |||
| complex(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | side | |||
| character, | intent(in) | :: | uplo | |||
| character, | intent(in) | :: | trans | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=dp), | intent(in) | :: | tau(*) | |||
| complex(kind=dp), | intent(inout) | :: | c(ldc,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldc | |||
| complex(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
CUNMTR overwrites the general complex M-by-N matrix C with SIDE = 'L' SIDE = 'R' TRANS = 'N': Q * C C * Q TRANS = 'C': QH * C C * QH where Q is a complex unitary matrix of order nq, with nq = m if SIDE = 'L' and nq = n if SIDE = 'R'. Q is defined as the product of nq-1 elementary reflectors, as returned by CHETRD: if UPLO = 'U', Q = H(nq-1) . . . H(2) H(1); if UPLO = 'L', Q = H(1) H(2) . . . H(nq-1).
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | side | |||
| character, | intent(in) | :: | uplo | |||
| character, | intent(in) | :: | trans | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=sp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=sp), | intent(in) | :: | tau(*) | |||
| complex(kind=sp), | intent(inout) | :: | c(ldc,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldc | |||
| complex(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
ZUNMTR overwrites the general complex M-by-N matrix C with SIDE = 'L' SIDE = 'R' TRANS = 'N': Q * C C * Q TRANS = 'C': QH * C C * QH where Q is a complex unitary matrix of order nq, with nq = m if SIDE = 'L' and nq = n if SIDE = 'R'. Q is defined as the product of nq-1 elementary reflectors, as returned by ZHETRD: if UPLO = 'U', Q = H(nq-1) . . . H(2) H(1); if UPLO = 'L', Q = H(1) H(2) . . . H(nq-1).
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | side | |||
| character, | intent(in) | :: | uplo | |||
| character, | intent(in) | :: | trans | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=dp), | intent(inout) | :: | a(lda,*) | |||
| integer(kind=ilp), | intent(in) | :: | lda | |||
| complex(kind=dp), | intent(in) | :: | tau(*) | |||
| complex(kind=dp), | intent(inout) | :: | c(ldc,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldc | |||
| complex(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(in) | :: | lwork | |||
| integer(kind=ilp), | intent(out) | :: | info |
UPGTR generates a complex unitary matrix Q which is defined as the product of n-1 elementary reflectors H(i) of order n, as returned by CHPTRD using packed storage: if UPLO = 'U', Q = H(n-1) . . . H(2) H(1), if UPLO = 'L', Q = H(1) H(2) . . . H(n-1).
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=sp), | intent(in) | :: | ap(*) | |||
| complex(kind=sp), | intent(in) | :: | tau(*) | |||
| complex(kind=sp), | intent(out) | :: | q(ldq,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldq | |||
| complex(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=dp), | intent(in) | :: | ap(*) | |||
| complex(kind=dp), | intent(in) | :: | tau(*) | |||
| complex(kind=dp), | intent(out) | :: | q(ldq,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldq | |||
| complex(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
CUPGTR generates a complex unitary matrix Q which is defined as the product of n-1 elementary reflectors H(i) of order n, as returned by CHPTRD using packed storage: if UPLO = 'U', Q = H(n-1) . . . H(2) H(1), if UPLO = 'L', Q = H(1) H(2) . . . H(n-1).
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=sp), | intent(in) | :: | ap(*) | |||
| complex(kind=sp), | intent(in) | :: | tau(*) | |||
| complex(kind=sp), | intent(out) | :: | q(ldq,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldq | |||
| complex(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
ZUPGTR generates a complex unitary matrix Q which is defined as the product of n-1 elementary reflectors H(i) of order n, as returned by ZHPTRD using packed storage: if UPLO = 'U', Q = H(n-1) . . . H(2) H(1), if UPLO = 'L', Q = H(1) H(2) . . . H(n-1).
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | uplo | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=dp), | intent(in) | :: | ap(*) | |||
| complex(kind=dp), | intent(in) | :: | tau(*) | |||
| complex(kind=dp), | intent(out) | :: | q(ldq,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldq | |||
| complex(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
UPMTR overwrites the general complex M-by-N matrix C with SIDE = 'L' SIDE = 'R' TRANS = 'N': Q * C C * Q TRANS = 'C': QH * C C * QH where Q is a complex unitary matrix of order nq, with nq = m if SIDE = 'L' and nq = n if SIDE = 'R'. Q is defined as the product of nq-1 elementary reflectors, as returned by CHPTRD using packed storage: if UPLO = 'U', Q = H(nq-1) . . . H(2) H(1); if UPLO = 'L', Q = H(1) H(2) . . . H(nq-1).
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | side | |||
| character, | intent(in) | :: | uplo | |||
| character, | intent(in) | :: | trans | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=sp), | intent(inout) | :: | ap(*) | |||
| complex(kind=sp), | intent(in) | :: | tau(*) | |||
| complex(kind=sp), | intent(inout) | :: | c(ldc,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldc | |||
| complex(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | side | |||
| character, | intent(in) | :: | uplo | |||
| character, | intent(in) | :: | trans | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=dp), | intent(inout) | :: | ap(*) | |||
| complex(kind=dp), | intent(in) | :: | tau(*) | |||
| complex(kind=dp), | intent(inout) | :: | c(ldc,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldc | |||
| complex(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
CUPMTR overwrites the general complex M-by-N matrix C with SIDE = 'L' SIDE = 'R' TRANS = 'N': Q * C C * Q TRANS = 'C': QH * C C * QH where Q is a complex unitary matrix of order nq, with nq = m if SIDE = 'L' and nq = n if SIDE = 'R'. Q is defined as the product of nq-1 elementary reflectors, as returned by CHPTRD using packed storage: if UPLO = 'U', Q = H(nq-1) . . . H(2) H(1); if UPLO = 'L', Q = H(1) H(2) . . . H(nq-1).
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | side | |||
| character, | intent(in) | :: | uplo | |||
| character, | intent(in) | :: | trans | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=sp), | intent(inout) | :: | ap(*) | |||
| complex(kind=sp), | intent(in) | :: | tau(*) | |||
| complex(kind=sp), | intent(inout) | :: | c(ldc,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldc | |||
| complex(kind=sp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |
ZUPMTR overwrites the general complex M-by-N matrix C with SIDE = 'L' SIDE = 'R' TRANS = 'N': Q * C C * Q TRANS = 'C': QH * C C * QH where Q is a complex unitary matrix of order nq, with nq = m if SIDE = 'L' and nq = n if SIDE = 'R'. Q is defined as the product of nq-1 elementary reflectors, as returned by ZHPTRD using packed storage: if UPLO = 'U', Q = H(nq-1) . . . H(2) H(1); if UPLO = 'L', Q = H(1) H(2) . . . H(nq-1).
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| character, | intent(in) | :: | side | |||
| character, | intent(in) | :: | uplo | |||
| character, | intent(in) | :: | trans | |||
| integer(kind=ilp), | intent(in) | :: | m | |||
| integer(kind=ilp), | intent(in) | :: | n | |||
| complex(kind=dp), | intent(inout) | :: | ap(*) | |||
| complex(kind=dp), | intent(in) | :: | tau(*) | |||
| complex(kind=dp), | intent(inout) | :: | c(ldc,*) | |||
| integer(kind=ilp), | intent(in) | :: | ldc | |||
| complex(kind=dp), | intent(out) | :: | work(*) | |||
| integer(kind=ilp), | intent(out) | :: | info |